diff --git a/public/docs/ts/_cache/glossary.jade b/public/docs/ts/_cache/glossary.jade
index 8d81e46cfd..b9cff1b0d2 100644
--- a/public/docs/ts/_cache/glossary.jade
+++ b/public/docs/ts/_cache/glossary.jade
@@ -25,7 +25,7 @@ block includes
a#aot
:marked
- ## Ahead-of-Time (AoT) compilation
+ ## Ahead-of-time (AOT) compilation
.l-sub-section
:marked
You can compile Angular applications at build-time.
@@ -393,7 +393,7 @@ a#H
a#jit
:marked
- ## Just-in-Time (JiT) compilation
+ ## Just-in-time (JIT) compilation
.l-sub-section
:marked
With Angular _just-in-time_ bootstrapping you compile your components and modules in the browser
diff --git a/public/docs/ts/_cache/guide/setup.jade b/public/docs/ts/_cache/guide/setup.jade
index a98c37c704..ee04e66a78 100644
--- a/public/docs/ts/_cache/guide/setup.jade
+++ b/public/docs/ts/_cache/guide/setup.jade
@@ -113,7 +113,7 @@ table(width="100%")
td main.ts
td
:marked
- Compiles the application with the [JiT compiler](../glossary.html#jit)
+ Compiles the application with the [JIT compiler](../glossary.html#jit)
and [bootstraps](appmodule.html#main "bootstrap the application") the application to run in the browser.
That's a reasonable choice for the development of most projects and
it's the only viable choice for a sample running in a _live-coding_ environment like Plunker.
diff --git a/public/docs/ts/latest/cookbook/aot-compiler.jade b/public/docs/ts/latest/cookbook/aot-compiler.jade
index 5c1f48852d..c928432572 100644
--- a/public/docs/ts/latest/cookbook/aot-compiler.jade
+++ b/public/docs/ts/latest/cookbook/aot-compiler.jade
@@ -1,7 +1,7 @@
include ../_util-fns
:marked
- This cookbook describes how to radically improve performance by compiling _Ahead of Time_ (AoT)
+ This cookbook describes how to radically improve performance by compiling _Ahead of Time_ (AOT)
during a build process.
a#toc
@@ -9,7 +9,7 @@ a#toc
## Table of Contents
* [Overview](#overview)
* [_Ahead-of-Time_ vs _Just-in-Time_](#aot-jit)
- * [Compile with AoT](#compile)
+ * [Compile with AOT](#compile)
* [Bootstrap](#bootstrap)
* [Tree Shaking](#tree-shaking)
* [Load the bundle](#load)
@@ -29,37 +29,37 @@ a#overview
:marked
Watch compiler author Tobias Bosch explain the Angular Compiler at AngularConnect 2016.
:marked
- You can compile the app in the browser, at runtime, as the application loads, using the **_Just-in-Time_ (JiT) compiler**.
+ You can compile the app in the browser, at runtime, as the application loads, using the **_Just-in-Time_ (JIT) compiler**.
This is the standard development approach shown throughout the documentation.
It's great .. but it has shortcomings.
- JiT compilation incurs a runtime performance penalty.
+ JIT compilation incurs a runtime performance penalty.
Views take longer to render because of the in-browser compilation step.
The application is bigger because it includes the Angular compiler
and a lot of library code that the application won't actually need.
Bigger apps take longer to transmit and are slower to load.
Compilation can uncover many component-template binding errors.
- JiT compilation discovers them at runtime which is later than we'd like.
+ JIT compilation discovers them at runtime which is later than we'd like.
- The **_Ahead-of-Time_ (AoT) compiler** can catch template errors early and improve performance
+ The **_Ahead-of-Time_ (AOT) compiler** can catch template errors early and improve performance
by compiling at build time as you'll learn in this chapter.
a#aot-jit
.l-main-section
:marked
- ## _Ahead-of-time_ (AoT) vs _Just-in-time_ (JiT)
+ ## _Ahead-of-time_ (AOT) vs _Just-in-time_ (JIT)
- There is actually only one Angular compiler. The difference between AoT and JiT is a matter of timing and tooling.
- With AoT, the compiler runs once at build time using one set of libraries;
- With JiT it runs every time for every user at runtime using a different set of libraries.
+ There is actually only one Angular compiler. The difference between AOT and JIT is a matter of timing and tooling.
+ With AOT, the compiler runs once at build time using one set of libraries;
+ With JIT it runs every time for every user at runtime using a different set of libraries.
- ### Why do AoT compilation?
+ ### Why do AOT compilation?
*Faster rendering*
- With AoT, the browser downloads a pre-compiled version of the application.
+ With AOT, the browser downloads a pre-compiled version of the application.
The browser loads executable code so it can render the application immediately, without waiting to compile the app first.
*Fewer asynchronous requests*
@@ -75,20 +75,20 @@ a#aot-jit
*Detect template errors earlier*
- The AoT compiler detects and reports template binding errors during the build step
+ The AOT compiler detects and reports template binding errors during the build step
before users can see them.
*Better security*
- AoT compiles HTML templates and components into JavaScript files long before they are served to the client.
+ AOT compiles HTML templates and components into JavaScript files long before they are served to the client.
With no templates to read and no risky client-side HTML or JavaScript evaluation,
there are fewer opportunities for injection attacks.
a#compile
.l-main-section
:marked
- ## Compile with AoT
+ ## Compile with AOT
### Prepare for offline compilation
Take the Setup as a starting point.
@@ -112,7 +112,7 @@ code-example(format='.').
`ngc` is a drop-in replacement for `tsc` and is configured much the same way.
- `ngc` requires its own `tsconfig.json` with AoT-oriented settings.
+ `ngc` requires its own `tsconfig.json` with AOT-oriented settings.
Copy the original `tsconfig.json` to a file called `tsconfig-aot.json`, then modify it to look as follows.
+makeExample('cb-aot-compiler/ts/tsconfig-aot.json', null, 'tsconfig-aot.json')(format='.')
@@ -132,14 +132,14 @@ code-example(format='.').
:marked
***Component-relative Template URLS***
- The AoT compiler requires that `@Component` URLS for external templates and css files be _component-relative_.
+ The AOT compiler requires that `@Component` URLS for external templates and css files be _component-relative_.
That means that the value of `@Component.templateUrl` is a URL value _relative_ to the component class file.
For example, an `'app.component.html'` URL means that the template file is a sibling of its companion `app.component.ts` file.
- While JiT app URLs are more flexible, stick with _component-relative_ URLs for compatibility with AoT compilation.
+ While JIT app URLs are more flexible, stick with _component-relative_ URLs for compatibility with AOT compilation.
- JiT-compiled applications that use the SystemJS loader and _component-relative_ URLs *must set the* `@Component.moduleId` *property to* `module.id`.
- The `module` object is undefined when an AoT-compiled app runs.
+ JIT-compiled applications that use the SystemJS loader and _component-relative_ URLs *must set the* `@Component.moduleId` *property to* `module.id`.
+ The `module` object is undefined when an AOT-compiled app runs.
The app fails with a null reference error unless you assign a global `module` value in the `index.html` like this:
+makeExample('cb-aot-compiler/ts/index.html','moduleId')(format='.')
.l-sub-section
@@ -149,7 +149,7 @@ code-example(format='.').
:marked
### Compiling the application
- Initiate AoT compilation from the command line using the previously installed `ngc` compiler by executing:
+ Initiate AOT compilation from the command line using the previously installed `ngc` compiler by executing:
code-example(format='.').
node_modules/.bin/ngc -p tsconfig-aot.json
.l-sub-section
@@ -171,8 +171,8 @@ code-example(format='.').
The curious can open the `aot/app.component.ngfactory.ts` to see the original Angular template syntax
in its intermediate, compiled-to-TypeScript form.
- JiT compilation generates these same _NgFactories_ in memory where they are largely invisible.
- AoT compilation reveals them as separate, physical files.
+ JIT compilation generates these same _NgFactories_ in memory where they are largely invisible.
+ AOT compilation reveals them as separate, physical files.
:marked
.alert.is-important
@@ -184,21 +184,21 @@ a#bootstrap
:marked
## Bootstrap
- The AoT path changes application bootstrapping.
+ The AOT path changes application bootstrapping.
Instead of bootstrapping `AppModule`, you bootstrap the application with the generated module factory, `AppModuleNgFactory`.
- Switch from the `platformBrowserDynamic.bootstrap` used in JiT compilation to
+ Switch from the `platformBrowserDynamic.bootstrap` used in JIT compilation to
`platformBrowser().bootstrapModuleFactory` and pass in the `AppModuleNgFactory`.
- Here is AoT bootstrap in `main.ts` next to the familiar JiT version:
+ Here is AOT bootstrap in `main.ts` next to the familiar JIT version:
+makeTabs(
`cb-aot-compiler/ts/app/main.ts,
cb-aot-compiler/ts/app/main-jit.ts`,
null,
- `app/main.ts (AoT),
- app/main.ts (JiT)`
+ `app/main.ts (AOT),
+ app/main.ts (JIT)`
)
:marked
@@ -208,7 +208,7 @@ a#tree-shaking
:marked
## Tree Shaking
- AoT compilation sets the stage for further optimization through a process called _Tree Shaking_.
+ AOT compilation sets the stage for further optimization through a process called _Tree Shaking_.
A Tree Shaker walks the dependency graph, top to bottom, and _shakes out_ unused code like
dead needles in a Christmas tree.
@@ -219,9 +219,9 @@ a#tree-shaking
For example, this demo application doesn't use anything from the `@angular/forms` library.
There is no reason to download Forms-related Angular code and tree shaking ensures that you don't.
- Tree Shaking and AoT compilation are separate steps.
+ Tree Shaking and AOT compilation are separate steps.
Tree Shaking can only target JavaScript code.
- AoT compilation converts more of the application to JavaScript,
+ AOT compilation converts more of the application to JavaScript,
which in turn makes more of the application "Tree Shakable".
### Rollup
@@ -323,7 +323,7 @@ code-example(format='.').
a#source-code
.l-main-section
:marked
- ## AoT QuickStart Source Code
+ ## AOT QuickStart Source Code
Here's the pertinent source code:
+makeTabs(
@@ -348,20 +348,20 @@ a#toh
## Tour of Heroes
The sample above is a trivial variation of the QuickStart app.
- In this section you apply what you've learned about AoT compilation and Tree Shaking
+ In this section you apply what you've learned about AOT compilation and Tree Shaking
to an app with more substance, the tutorial [_Tour of Heroes_](../tutorial/toh-pt6.html).
- ### JiT in development, AoT in production
+ ### JIT in development, AOT in production
- Today AoT compilation and Tree Shaking take more time than is practical for development. That will change soon.
- For now, it's best to JiT compile in development and switch to AoT compilation before deploying to production.
+ Today AOT compilation and Tree Shaking take more time than is practical for development. That will change soon.
+ For now, it's best to JIT compile in development and switch to AOT compilation before deploying to production.
Fortunately, the source code can be compiled either way without change _if_ you account for a few key differences.
***index.html***
- The JiT and AoT apps require their own `index.html` files because they setup and launch so differently.
- **Put the AoT version in the `/aot` folder** because two `index.html` files can't be in the same folder.
+ The JIT and AOT apps require their own `index.html` files because they setup and launch so differently.
+ **Put the AOT version in the `/aot` folder** because two `index.html` files can't be in the same folder.
Here they are for comparison:
@@ -369,20 +369,20 @@ a#toh
`toh-6/ts/aot/index.html,
toh-6/ts/index.html`,
null,
- `aot/index.html (AoT),
- index.html (JiT)`
+ `aot/index.html (AOT),
+ index.html (JIT)`
)
:marked
- The JiT version relies on `SystemJS` to load individual modules and requires the `reflect-metadata` shim.
+ The JIT version relies on `SystemJS` to load individual modules and requires the `reflect-metadata` shim.
Both scripts appear in its `index.html`.
- The AoT version loads the entire application in a single script, `aot/dist/build.js`.
+ The AOT version loads the entire application in a single script, `aot/dist/build.js`.
It does not need `SystemJS` or the `reflect-metadata` shim; those scripts are absent from its `index.html`
***main.ts***
- JiT and AoT applications boot in much the same way but require different Angular libraries to do so.
+ JIT and AOT applications boot in much the same way but require different Angular libraries to do so.
The key differences, covered in the [Bootstrap](#bootstrap) section above,
are evident in these `main` files which can and should reside in the same folder:
@@ -390,16 +390,16 @@ a#toh
`toh-6/ts/app/main-aot.ts,
toh-6/ts/app/main.ts`,
null,
- `app/main-aot.ts (AoT),
- app/main.ts (JiT)`
+ `app/main-aot.ts (AOT),
+ app/main.ts (JIT)`
)
:marked
***TypeScript configuration***
- JiT-compiled applications transpile to `commonjs` modules.
- AoT-compiled applications transpile to _ES2015_/_ES6_ modules to facilitate Tree Shaking.
- AoT requires its own TypeScript configuration settings as well.
+ JIT-compiled applications transpile to `commonjs` modules.
+ AOT-compiled applications transpile to _ES2015_/_ES6_ modules to facilitate Tree Shaking.
+ AOT requires its own TypeScript configuration settings as well.
You'll need separate TypeScript configuration files such as these:
@@ -407,8 +407,8 @@ a#toh
`toh-6/ts/tsconfig-aot.json,
toh-6/ts/tsconfig.json`,
null,
- `tsconfig-aot.json (AoT),
- tsconfig.json (JiT)`
+ `tsconfig-aot.json (AOT),
+ tsconfig.json (JIT)`
)
.callout.is-helpful
@@ -434,7 +434,7 @@ a#toh
.alert.is-important
:marked
- The general audience instructions for running the AoT build of the Tour of Heroes app are not ready.
+ The general audience instructions for running the AOT build of the Tour of Heroes app are not ready.
The following instructions presuppose that you have cloned the
angular.io
@@ -442,9 +442,9 @@ a#toh
The _Tour of Heroes_ source code is in the `public/docs/_examples/toh-6/ts` folder.
:marked
- Run the JiT-compiled app with `npm start` as for all other JiT examples.
+ Run the JIT-compiled app with `npm start` as for all other JIT examples.
- Compiling with AoT presupposes certain supporting files, most of them discussed above.
+ Compiling with AOT presupposes certain supporting files, most of them discussed above.
+makeTabs(
`toh-6/ts/aot/index.html,
toh-6/ts/aot/bs-config.json,
@@ -463,14 +463,14 @@ code-example(format='.').
"build:aot": "ngc -p tsconfig-aot.json && rollup -c rollup-config.js",
"lite:aot": "lite-server -c aot/bs-config.json",
:marked
- Copy the AoT distribution files into the `/aot` folder with the node script:
+ Copy the AOT distribution files into the `/aot` folder with the node script:
code-example(format='.').
node copy-dist-files
.l-sub-section
:marked
You won't do that again until there are updates to `zone.js` or the `core-js` shim for old browsers.
:marked
- Now AoT-compile the app and launch it with the `lite` server:
+ Now AOT-compile the app and launch it with the `lite` server:
code-example(format='.').
npm run build:aot && npm run lite:aot
diff --git a/public/docs/ts/latest/cookbook/i18n.jade b/public/docs/ts/latest/cookbook/i18n.jade
index d0a16541e5..592c7a8624 100644
--- a/public/docs/ts/latest/cookbook/i18n.jade
+++ b/public/docs/ts/latest/cookbook/i18n.jade
@@ -14,13 +14,13 @@ a#top
* [Use the **_ng-xi18n_ extraction tool** to create a translation source file](#ng-xi18n)
* [Translate](#translate)
* [Merge the completed translation file into the app](#merge)
- * [JiT configuration](#jit)
- * [AoT configuration](#aot)
+ * [JIT configuration](#jit)
+ * [AOT configuration](#aot)
* [Translation file maintenance and _id_ changes](#maintenance)
:marked
**Try this** live example
- of a JiT-compiled app, translated into Spanish.
+ of a JIT-compiled app, translated into Spanish.
a#angular-i18n
@@ -417,22 +417,22 @@ a#merge
(`es` or `en-US` for instance)
_How_ you provide this information depends upon whether you compile with
- the JiT (_Just-in-Time_) compiler or the AoT (_Ahead-of-Time_) compiler.
+ the JIT (_Just-in-Time_) compiler or the AOT (_Ahead-of-Time_) compiler.
- * with [JiT](#jit), you provide the information at bootstrap time.
- * with [AoT](#aot), you pass the information as `ngc` options.
+ * with [JIT](#jit), you provide the information at bootstrap time.
+ * with [AOT](#aot), you pass the information as `ngc` options.
a#jit
.l-main-section
:marked
- ### Merge with the JiT compiler
+ ### Merge with the JIT compiler
- The JiT (_Just-in-Time_) compiler compiles the application in the browser as the application loads.
- Translation with the JiT compiler is a dynamic process of ...
+ The JIT (_Just-in-Time_) compiler compiles the application in the browser as the application loads.
+ Translation with the JIT compiler is a dynamic process of ...
1. determining the language version for the current user,
2. importing the appropriate language translation file as a string constant,
- 3. creating corresponding translation providers to guide the JiT compiler,
+ 3. creating corresponding translation providers to guide the JIT compiler,
4. bootstrapping the application with those providers.
Open `index.html` and revise the launch script as shown here:
@@ -456,7 +456,7 @@ a#text-plugin
:marked
### Create translation providers
- Three providers tell the JiT compiler how to translate the template texts for a particular language
+ Three providers tell the JIT compiler how to translate the template texts for a particular language
while compiling the application:
* `TRANSLATIONS` is a string containing the content of the translation file.
@@ -503,28 +503,28 @@ a#text-plugin
a#aot
.l-main-section
:marked
- ### _Internationalize_ with the AoT compiler
+ ### _Internationalize_ with the AOT compiler
- The JiT compiler translates the application into the target language while compiling dynamically in the browser.
+ The JIT compiler translates the application into the target language while compiling dynamically in the browser.
That's flexible but may not be fast enough for your users.
- The AoT (_Ahead-of-Time_) compiler is part of a build process that produces a small, fast, ready-to-run application package.
- When you internationalize with the AoT compiler, you pre-build a separate application package for each
+ The AOT (_Ahead-of-Time_) compiler is part of a build process that produces a small, fast, ready-to-run application package.
+ When you internationalize with the AOT compiler, you pre-build a separate application package for each
language. Then in the host web page (`index.html`), you determine which language the user needs
and serve the appropriate application package.
This cookbook doesn't cover how to build multiple application packages and
serve them according to the user's language preference.
- It does explain the few steps necessary to tell the AoT to apply a translations file.
+ It does explain the few steps necessary to tell the AOT to apply a translations file.
- Internationalization with the AoT compiler requires some setup specifically for AoT.
+ Internationalization with the AOT compiler requires some setup specifically for AOT.
Start with application project as shown [just before merging the translation file](#app-pre-translationStart)
- and refer to the [AoT cookbook](aot-compiler.html) to make it _AoT-ready_.
+ and refer to the [AOT cookbook](aot-compiler.html) to make it _AoT-ready_.
Next, issue an `ngc` compile command for each supported language (including English).
The result is a separate version of the application for each language.
- Tell AoT how to translate by adding three options to the `ngc` command:
+ Tell AOT how to translate by adding three options to the `ngc` command:
* `--i18nFile`: the path to the translation file
* `--locale`: the name of the locale
* `--i18nFormat`: the format of the localization file
diff --git a/public/docs/ts/latest/cookbook/ts-to-js.jade b/public/docs/ts/latest/cookbook/ts-to-js.jade
index ab84037c0b..2413f80ba0 100644
--- a/public/docs/ts/latest/cookbook/ts-to-js.jade
+++ b/public/docs/ts/latest/cookbook/ts-to-js.jade
@@ -24,7 +24,7 @@ a#toc
[Dependency Injection](#dependency-injection)
[Host Binding](#host-binding)
[View and Child Decorators](#view-child-decorators)
- [AoT compilation in _TypeScript_ Only](#aot)
+ [AOT compilation in _TypeScript_ Only](#aot)
**Run and compare the live _TypeScript_ and JavaScript
code shown in this cookbook.**
@@ -660,10 +660,10 @@ a#view-child-decorators
a#aot
.l-main-section
:marked
- ## AoT Compilation in _TypeScript_ only
+ ## AOT Compilation in _TypeScript_ only
- Angular offers two modes of template compilation, JiT (_Just-in-Time_) and
- [AoT (_Ahead-of-Time_)](aot-compiler.html).
- Currently the AoT compiler only works with _TypeScript_ applications because, in part, it generates
+ Angular offers two modes of template compilation, JIT (_Just-in-Time_) and
+ [AOT (_Ahead-of-Time_)](aot-compiler.html).
+ Currently the AOT compiler only works with _TypeScript_ applications because, in part, it generates
_TypeScript_ files as an intermediate result.
- **AoT is not an option for pure JavaScript applications** at this time.
+ **AOT is not an option for pure JavaScript applications** at this time.
diff --git a/public/docs/ts/latest/glossary.jade b/public/docs/ts/latest/glossary.jade
index 02e5d8cf73..59a8b8230f 100644
--- a/public/docs/ts/latest/glossary.jade
+++ b/public/docs/ts/latest/glossary.jade
@@ -25,7 +25,7 @@ block includes
a#aot
:marked
- ## Ahead-of-Time (AoT) compilation
+ ## Ahead-of-time (AOT) compilation
.l-sub-section
:marked
You can compile Angular applications at build-time.
@@ -393,7 +393,7 @@ a#H
a#jit
:marked
- ## Just-in-Time (JiT) compilation
+ ## Just-in-time (JIT) compilation
.l-sub-section
:marked
With Angular _just-in-time_ bootstrapping you compile your components and modules in the browser
diff --git a/public/docs/ts/latest/guide/appmodule.jade b/public/docs/ts/latest/guide/appmodule.jade
index 438c04e180..ab9c68d258 100644
--- a/public/docs/ts/latest/guide/appmodule.jade
+++ b/public/docs/ts/latest/guide/appmodule.jade
@@ -99,14 +99,14 @@ l-main-section
There are many ways to bootstrap an application.
The variations depend upon how you want to compile the application and where you want to run it.
- In the beginning, you will compile the application dynamically with the _Just-in-Time (JiT)_ compiler
+ In the beginning, you will compile the application dynamically with the _Just-in-Time (JIT)_ compiler
and you'll run it in a browser. You can learn about other options later.
- The recommended place to bootstrap a JiT-compiled browser application is in a separate file
+ The recommended place to bootstrap a JIT-compiled browser application is in a separate file
in the `app` folder named `app/main.ts`
+makeExample('setup/ts/app/main.ts','','app/main.ts')(format='.')
:marked
- This code creates a browser platform for dynamic (JiT) compilation and
+ This code creates a browser platform for dynamic (JIT) compilation and
bootstraps the `AppModule` described above.
The _bootstrapping_ process sets up the execution environment,
diff --git a/public/docs/ts/latest/guide/change-log.jade b/public/docs/ts/latest/guide/change-log.jade
index 5780d51fb3..bcc70625f2 100644
--- a/public/docs/ts/latest/guide/change-log.jade
+++ b/public/docs/ts/latest/guide/change-log.jade
@@ -29,9 +29,9 @@ block includes
## Sync with Angular v.2.2.0 (2016-11-14)
Docs and code samples updated and tested with Angular v.2.2.0
- ## UPDATE: NgUpgrade Guide for the AoT friendly _upgrade/static_ module (2016-11-14)
+ ## UPDATE: NgUpgrade Guide for the AOT friendly _upgrade/static_ module (2016-11-14)
The updated [NgUpgrade Guide](upgrade.html) guide covers the
- new AoT friendly `upgrade/static` module
+ new AOT friendly `upgrade/static` module
released in v.2.2.0, which is the recommended
facility for migrating from Angular 1 to Angular 2.
The documentation for the version prior to v.2.2.0 has been removed.
@@ -73,9 +73,9 @@ block includes
## Sync with Angular v.2.1.0 (2016-10-12)
Docs and code samples updated and tested with Angular v.2.1.0
- ## NEW "Ahead of Time (AoT) Compilation" cookbook (2016-10-11)
- The NEW [Ahead of Time (AoT) Compilation](../cookbook/aot-compiler.html) cookbook
- explains what AoT compilation is and why you'd want it.
+ ## NEW "Ahead of time (AOT) Compilation" cookbook (2016-10-11)
+ The NEW [Ahead of time (AOT) Compilation](../cookbook/aot-compiler.html) cookbook
+ explains what AOT compilation is and why you'd want it.
It demonstrates the basics with a QuickStart app
followed by the more advanced considerations of compiling and bundling the Tour of Heroes.
@@ -118,7 +118,7 @@ block includes
have been converted to _module-relative_ URLs.
We added the `moduleId: module.id` property-and-value to their `@Component` metadata.
- This change is a requirement for compilation with AoT compiler when the app loads
+ This change is a requirement for compilation with AOT compiler when the app loads
modules with SystemJS as the samples currently do.
## "Lifecycle Hooks" guide simplified (2016-09-24)
diff --git a/public/docs/ts/latest/guide/ngmodule.jade b/public/docs/ts/latest/guide/ngmodule.jade
index 8d575723bb..74b3d83f74 100644
--- a/public/docs/ts/latest/guide/ngmodule.jade
+++ b/public/docs/ts/latest/guide/ngmodule.jade
@@ -136,7 +136,7 @@ a#bootstrap
Angular offers a variety of bootstrapping options, targeting multiple platforms.
In this page we consider two options, both targeting the browser.
- ### Dynamic bootstrapping with the Just-in-time (JiT) compiler
+ ### Dynamic bootstrapping with the Just-in-time (JIT) compiler
In the first, _dynamic_ option, the [Angular compiler](../cookbook/ngmodule-faq.html#q-angular-compiler "About the Angular Compiler")
compiles the application in the browser and then launches the app.
@@ -147,7 +147,7 @@ a#bootstrap
Try the live example.
- ### Static bootstrapping with the Ahead-Of-time (AoT) compiler
+ ### Static bootstrapping with the Ahead-Of-time (AOT) compiler
Consider the static alternative which can produce a much smaller application that
launches faster, especially on mobile devices and high latency networks.
@@ -167,10 +167,10 @@ a#bootstrap
The application code downloaded to the browser is much smaller than the dynamic equivalent
and it is ready to execute immediately. The performance boost can be significant.
- Both the JiT and AoT compilers generate an `AppModuleNgFactory` class from the same `AppModule`
+ Both the JIT and AOT compilers generate an `AppModuleNgFactory` class from the same `AppModule`
source code.
- The JiT compiler creates that factory class on the fly, in memory, in the browser.
- The AoT compiler outputs the factory to a physical file
+ The JIT compiler creates that factory class on the fly, in memory, in the browser.
+ The AOT compiler outputs the factory to a physical file
that we're importing here in the static version of `main.ts`.
In general, the `AppModule` should neither know nor care how it is bootstrapped.
diff --git a/public/docs/ts/latest/guide/setup.jade b/public/docs/ts/latest/guide/setup.jade
index a98c37c704..ee04e66a78 100644
--- a/public/docs/ts/latest/guide/setup.jade
+++ b/public/docs/ts/latest/guide/setup.jade
@@ -113,7 +113,7 @@ table(width="100%")
td main.ts
td
:marked
- Compiles the application with the [JiT compiler](../glossary.html#jit)
+ Compiles the application with the [JIT compiler](../glossary.html#jit)
and [bootstraps](appmodule.html#main "bootstrap the application") the application to run in the browser.
That's a reasonable choice for the development of most projects and
it's the only viable choice for a sample running in a _live-coding_ environment like Plunker.
diff --git a/public/docs/ts/latest/index.jade b/public/docs/ts/latest/index.jade
index aa1ffea3c4..f8d6236c90 100644
--- a/public/docs/ts/latest/index.jade
+++ b/public/docs/ts/latest/index.jade
@@ -40,7 +40,7 @@
h4 Cookbook
ul
li
- a(href="/docs/#{lang}/#{vers}/cookbook/aot-compiler.html") Ahead-of-Time Compilation
+ a(href="/docs/#{lang}/#{vers}/cookbook/aot-compiler.html") Ahead-of-time Compilation
li
a(href="/docs/#{lang}/#{vers}/cookbook/a1-a2-quick-reference.html") Angular 1 to Angular 2
li