2016-06-23 09:47:54 -07:00
/ * *
* @license
* Copyright Google Inc . All Rights Reserved .
*
* Use of this source code is governed by an MIT - style license that can be
* found in the LICENSE file at https : //angular.io/license
* /
2016-06-10 10:21:53 -07:00
import { COMMON_DIRECTIVES , COMMON_PIPES } from '@angular/common' ;
import { COMPILER_PROVIDERS , CompilerConfig , XHR } from '@angular/compiler' ;
2016-07-07 14:42:46 -07:00
import { AppModule , AppModuleRef , ApplicationRef , Compiler , ComponentRef , ComponentResolver , ExceptionHandler , PLATFORM_DIRECTIVES , PLATFORM_PIPES , ReflectiveInjector , Type , coreLoadAndBootstrap , isDevMode } from '@angular/core' ;
feat(browser): use AppModules for bootstrap in the browser
This introduces the `BrowserModule` to be used for long form
bootstrap and offline compile bootstrap:
```
@AppModule({
modules: [BrowserModule],
precompile: [MainComponent],
providers: […], // additional providers
directives: […], // additional platform directives
pipes: […] // additional platform pipes
})
class MyModule {
constructor(appRef: ApplicationRef) {
appRef.bootstrap(MainComponent);
}
}
// offline compile
import {bootstrapModuleFactory} from ‘@angular/platform-browser’;
bootstrapModuleFactory(MyModuleNgFactory);
// runtime compile long form
import {bootstrapModule} from ‘@angular/platform-browser-dynamic’;
bootstrapModule(MyModule);
```
The short form, `bootstrap(...)`, can now creates a module on the fly,
given `directives`, `pipes, `providers`, `precompile` and `modules`
properties.
Related changes:
- make `SanitizationService`, `SecurityContext` public in `@angular/core` so that the offline compiler can resolve the token
- move `AnimationDriver` to `platform-browser` and make it
public so that the offline compiler can resolve the token
BREAKING CHANGES:
- short form bootstrap does no longer allow
to inject compiler internals (i.e. everything
from `@angular/compiler). Inject `Compiler` instead.
To provide custom providers for the compiler,
create a custom compiler via `browserCompiler({providers: [...]})`
and pass that into the `bootstrap` method.
2016-06-30 13:07:17 -07:00
import { BROWSER_APP_PROVIDERS , BrowserModule , WORKER_APP_APPLICATION_PROVIDERS , WORKER_SCRIPT , WORKER_UI_APPLICATION_PROVIDERS , bootstrapModuleFactory , browserPlatform , workerAppPlatform , workerUiPlatform } from '@angular/platform-browser' ;
2016-06-08 16:38:52 -07:00
2016-07-07 11:57:11 -07:00
import { Console , ReflectionCapabilities , reflector } from './core_private' ;
feat(browser): use AppModules for bootstrap in the browser
This introduces the `BrowserModule` to be used for long form
bootstrap and offline compile bootstrap:
```
@AppModule({
modules: [BrowserModule],
precompile: [MainComponent],
providers: […], // additional providers
directives: […], // additional platform directives
pipes: […] // additional platform pipes
})
class MyModule {
constructor(appRef: ApplicationRef) {
appRef.bootstrap(MainComponent);
}
}
// offline compile
import {bootstrapModuleFactory} from ‘@angular/platform-browser’;
bootstrapModuleFactory(MyModuleNgFactory);
// runtime compile long form
import {bootstrapModule} from ‘@angular/platform-browser-dynamic’;
bootstrapModule(MyModule);
```
The short form, `bootstrap(...)`, can now creates a module on the fly,
given `directives`, `pipes, `providers`, `precompile` and `modules`
properties.
Related changes:
- make `SanitizationService`, `SecurityContext` public in `@angular/core` so that the offline compiler can resolve the token
- move `AnimationDriver` to `platform-browser` and make it
public so that the offline compiler can resolve the token
BREAKING CHANGES:
- short form bootstrap does no longer allow
to inject compiler internals (i.e. everything
from `@angular/compiler). Inject `Compiler` instead.
To provide custom providers for the compiler,
create a custom compiler via `browserCompiler({providers: [...]})`
and pass that into the `bootstrap` method.
2016-06-30 13:07:17 -07:00
import { getDOM , initDomAdapter } from './platform_browser_private' ;
2016-06-10 10:21:53 -07:00
import { PromiseWrapper } from './src/facade/async' ;
feat(browser): use AppModules for bootstrap in the browser
This introduces the `BrowserModule` to be used for long form
bootstrap and offline compile bootstrap:
```
@AppModule({
modules: [BrowserModule],
precompile: [MainComponent],
providers: […], // additional providers
directives: […], // additional platform directives
pipes: […] // additional platform pipes
})
class MyModule {
constructor(appRef: ApplicationRef) {
appRef.bootstrap(MainComponent);
}
}
// offline compile
import {bootstrapModuleFactory} from ‘@angular/platform-browser’;
bootstrapModuleFactory(MyModuleNgFactory);
// runtime compile long form
import {bootstrapModule} from ‘@angular/platform-browser-dynamic’;
bootstrapModule(MyModule);
```
The short form, `bootstrap(...)`, can now creates a module on the fly,
given `directives`, `pipes, `providers`, `precompile` and `modules`
properties.
Related changes:
- make `SanitizationService`, `SecurityContext` public in `@angular/core` so that the offline compiler can resolve the token
- move `AnimationDriver` to `platform-browser` and make it
public so that the offline compiler can resolve the token
BREAKING CHANGES:
- short form bootstrap does no longer allow
to inject compiler internals (i.e. everything
from `@angular/compiler). Inject `Compiler` instead.
To provide custom providers for the compiler,
create a custom compiler via `browserCompiler({providers: [...]})`
and pass that into the `bootstrap` method.
2016-06-30 13:07:17 -07:00
import { ConcreteType , isPresent , stringify } from './src/facade/lang' ;
2016-06-10 10:21:53 -07:00
import { CachedXHR } from './src/xhr/xhr_cache' ;
import { XHRImpl } from './src/xhr/xhr_impl' ;
2016-05-24 16:13:17 -07:00
feat(browser): use AppModules for bootstrap in the browser
This introduces the `BrowserModule` to be used for long form
bootstrap and offline compile bootstrap:
```
@AppModule({
modules: [BrowserModule],
precompile: [MainComponent],
providers: […], // additional providers
directives: […], // additional platform directives
pipes: […] // additional platform pipes
})
class MyModule {
constructor(appRef: ApplicationRef) {
appRef.bootstrap(MainComponent);
}
}
// offline compile
import {bootstrapModuleFactory} from ‘@angular/platform-browser’;
bootstrapModuleFactory(MyModuleNgFactory);
// runtime compile long form
import {bootstrapModule} from ‘@angular/platform-browser-dynamic’;
bootstrapModule(MyModule);
```
The short form, `bootstrap(...)`, can now creates a module on the fly,
given `directives`, `pipes, `providers`, `precompile` and `modules`
properties.
Related changes:
- make `SanitizationService`, `SecurityContext` public in `@angular/core` so that the offline compiler can resolve the token
- move `AnimationDriver` to `platform-browser` and make it
public so that the offline compiler can resolve the token
BREAKING CHANGES:
- short form bootstrap does no longer allow
to inject compiler internals (i.e. everything
from `@angular/compiler). Inject `Compiler` instead.
To provide custom providers for the compiler,
create a custom compiler via `browserCompiler({providers: [...]})`
and pass that into the `bootstrap` method.
2016-06-30 13:07:17 -07:00
2016-06-27 12:27:23 -07:00
/ * *
* @experimental
* /
2016-06-10 10:21:53 -07:00
export const BROWSER_APP_COMPILER_PROVIDERS : Array < any /*Type | Provider | any[]*/ > = [
2016-06-14 18:23:40 -07:00
COMPILER_PROVIDERS , {
2016-06-10 10:21:53 -07:00
provide : CompilerConfig ,
2016-06-14 18:23:40 -07:00
useFactory : ( platformDirectives : any [ ] , platformPipes : any [ ] ) = > {
return new CompilerConfig ( { platformDirectives , platformPipes } ) ;
} ,
deps : [ PLATFORM_DIRECTIVES , PLATFORM_PIPES ]
2016-06-10 10:21:53 -07:00
} ,
{ provide : XHR , useClass : XHRImpl } ,
2016-06-14 18:23:40 -07:00
{ provide : PLATFORM_DIRECTIVES , useValue : COMMON_DIRECTIVES , multi : true } ,
{ provide : PLATFORM_PIPES , useValue : COMMON_PIPES , multi : true }
2016-06-10 10:21:53 -07:00
] ;
2016-05-24 16:13:17 -07:00
2016-06-10 10:21:53 -07:00
2016-06-27 12:27:23 -07:00
/ * *
* @experimental
* /
2016-06-10 10:21:53 -07:00
export const CACHED_TEMPLATE_PROVIDER : Array < any /*Type | Provider | any[]*/ > =
[ { provide : XHR , useClass : CachedXHR } ] ;
feat(browser): use AppModules for bootstrap in the browser
This introduces the `BrowserModule` to be used for long form
bootstrap and offline compile bootstrap:
```
@AppModule({
modules: [BrowserModule],
precompile: [MainComponent],
providers: […], // additional providers
directives: […], // additional platform directives
pipes: […] // additional platform pipes
})
class MyModule {
constructor(appRef: ApplicationRef) {
appRef.bootstrap(MainComponent);
}
}
// offline compile
import {bootstrapModuleFactory} from ‘@angular/platform-browser’;
bootstrapModuleFactory(MyModuleNgFactory);
// runtime compile long form
import {bootstrapModule} from ‘@angular/platform-browser-dynamic’;
bootstrapModule(MyModule);
```
The short form, `bootstrap(...)`, can now creates a module on the fly,
given `directives`, `pipes, `providers`, `precompile` and `modules`
properties.
Related changes:
- make `SanitizationService`, `SecurityContext` public in `@angular/core` so that the offline compiler can resolve the token
- move `AnimationDriver` to `platform-browser` and make it
public so that the offline compiler can resolve the token
BREAKING CHANGES:
- short form bootstrap does no longer allow
to inject compiler internals (i.e. everything
from `@angular/compiler). Inject `Compiler` instead.
To provide custom providers for the compiler,
create a custom compiler via `browserCompiler({providers: [...]})`
and pass that into the `bootstrap` method.
2016-06-30 13:07:17 -07:00
function _initGlobals() {
initDomAdapter ( ) ;
reflector . reflectionCapabilities = new ReflectionCapabilities ( ) ;
}
/ * *
* Creates the runtime compiler for the browser .
*
* @stable
* /
export function browserCompiler ( { useDebug , useJit = true , providers = [ ] } : {
useDebug? : boolean ,
useJit? : boolean ,
providers? : Array < any /*Type | Provider | any[]*/ >
} = { } ) : Compiler {
_initGlobals ( ) ;
if ( useDebug === undefined ) {
useDebug = isDevMode ( ) ;
}
const injector = ReflectiveInjector . resolveAndCreate ( [
COMPILER_PROVIDERS , {
provide : CompilerConfig ,
useValue : new CompilerConfig ( { genDebugInfo : useDebug , useJit : useJit } )
} ,
{ provide : XHR , useClass : XHRImpl } , providers ? providers : [ ]
] ) ;
return injector . get ( Compiler ) ;
}
2016-06-10 10:21:53 -07:00
feat(browser): use AppModules for bootstrap in the browser
This introduces the `BrowserModule` to be used for long form
bootstrap and offline compile bootstrap:
```
@AppModule({
modules: [BrowserModule],
precompile: [MainComponent],
providers: […], // additional providers
directives: […], // additional platform directives
pipes: […] // additional platform pipes
})
class MyModule {
constructor(appRef: ApplicationRef) {
appRef.bootstrap(MainComponent);
}
}
// offline compile
import {bootstrapModuleFactory} from ‘@angular/platform-browser’;
bootstrapModuleFactory(MyModuleNgFactory);
// runtime compile long form
import {bootstrapModule} from ‘@angular/platform-browser-dynamic’;
bootstrapModule(MyModule);
```
The short form, `bootstrap(...)`, can now creates a module on the fly,
given `directives`, `pipes, `providers`, `precompile` and `modules`
properties.
Related changes:
- make `SanitizationService`, `SecurityContext` public in `@angular/core` so that the offline compiler can resolve the token
- move `AnimationDriver` to `platform-browser` and make it
public so that the offline compiler can resolve the token
BREAKING CHANGES:
- short form bootstrap does no longer allow
to inject compiler internals (i.e. everything
from `@angular/compiler). Inject `Compiler` instead.
To provide custom providers for the compiler,
create a custom compiler via `browserCompiler({providers: [...]})`
and pass that into the `bootstrap` method.
2016-06-30 13:07:17 -07:00
/ * *
* Creates an instance of an ` @AppModule ` for the browser platform .
*
* # # Simple Example
*
* ` ` ` typescript
* @AppModule ( {
* modules : [ BrowserModule ]
* } )
* class MyModule { }
*
* let moduleRef = bootstrapModule ( MyModule ) ;
* ` ` `
* @stable
* /
export function bootstrapModule < M > (
moduleType : ConcreteType < M > , compiler : Compiler = browserCompiler ( ) ) : Promise < AppModuleRef < M > > {
return compiler . compileAppModuleAsync ( moduleType ) . then ( bootstrapModuleFactory ) ;
}
2016-06-10 10:21:53 -07:00
/ * *
* Bootstrapping for Angular applications .
*
* You instantiate an Angular application by explicitly specifying a component to use
* as the root component for your application via the ` bootstrap() ` method .
*
* # # Simple Example
*
* Assuming this ` index.html ` :
*
* ` ` ` html
* < html >
* <!-- load Angular script tags here. -->
* < body >
* < my - app > loading . . . < / m y - a p p >
* < / body >
* < / html >
* ` ` `
*
* An application is bootstrapped inside an existing browser DOM , typically ` index.html ` .
* Unlike Angular 1 , Angular 2 does not compile / process providers in ` index.html ` . This is
* mainly for security reasons , as well as architectural changes in Angular 2 . This means
* that ` index.html ` can safely be processed using server - side technologies such as
* providers . Bindings can thus use double - curly ` {{ syntax }} ` without collision from
* Angular 2 component double - curly ` {{ syntax }} ` .
*
* We can use this script code :
*
* { @example core / ts / bootstrap / bootstrap . ts region = 'bootstrap' }
*
* When the app developer invokes ` bootstrap() ` with the root component ` MyApp ` as its
* argument , Angular performs the following tasks :
*
* 1 . It uses the component ' s ` selector ` property to locate the DOM element which needs
* to be upgraded into the angular component .
* 2 . It creates a new child injector ( from the platform injector ) . Optionally , you can
* also override the injector configuration for an app by invoking ` bootstrap ` with the
* ` componentInjectableBindings ` argument .
* 3 . It creates a new ` Zone ` and connects it to the angular application ' s change detection
* domain instance .
* 4 . It creates an emulated or shadow DOM on the selected component ' s host element and loads the
* template into it .
* 5 . It instantiates the specified component .
* 6 . Finally , Angular performs change detection to apply the initial data providers for the
* application .
*
*
* # # Bootstrapping Multiple Applications
*
* When working within a browser window , there are many singleton resources : cookies , title ,
* location , and others . Angular services that represent these resources must likewise be
* shared across all Angular applications that occupy the same browser window . For this
* reason , Angular creates exactly one global platform object which stores all shared
* services , and each angular application injector has the platform injector as its parent .
*
* Each application has its own private injector as well . When there are multiple
* applications on a page , Angular treats each application injector ' s services as private
* to that application .
*
feat(browser): use AppModules for bootstrap in the browser
This introduces the `BrowserModule` to be used for long form
bootstrap and offline compile bootstrap:
```
@AppModule({
modules: [BrowserModule],
precompile: [MainComponent],
providers: […], // additional providers
directives: […], // additional platform directives
pipes: […] // additional platform pipes
})
class MyModule {
constructor(appRef: ApplicationRef) {
appRef.bootstrap(MainComponent);
}
}
// offline compile
import {bootstrapModuleFactory} from ‘@angular/platform-browser’;
bootstrapModuleFactory(MyModuleNgFactory);
// runtime compile long form
import {bootstrapModule} from ‘@angular/platform-browser-dynamic’;
bootstrapModule(MyModule);
```
The short form, `bootstrap(...)`, can now creates a module on the fly,
given `directives`, `pipes, `providers`, `precompile` and `modules`
properties.
Related changes:
- make `SanitizationService`, `SecurityContext` public in `@angular/core` so that the offline compiler can resolve the token
- move `AnimationDriver` to `platform-browser` and make it
public so that the offline compiler can resolve the token
BREAKING CHANGES:
- short form bootstrap does no longer allow
to inject compiler internals (i.e. everything
from `@angular/compiler). Inject `Compiler` instead.
To provide custom providers for the compiler,
create a custom compiler via `browserCompiler({providers: [...]})`
and pass that into the `bootstrap` method.
2016-06-30 13:07:17 -07:00
* # # API ( version 1 )
2016-06-10 10:21:53 -07:00
*
* - ` appComponentType ` : The root component which should act as the application . This is
* a reference to a ` Type ` which is annotated with ` @Component(...) ` .
* - ` customProviders ` : An additional set of providers that can be added to the
* app injector to override default injection behavior .
*
feat(browser): use AppModules for bootstrap in the browser
This introduces the `BrowserModule` to be used for long form
bootstrap and offline compile bootstrap:
```
@AppModule({
modules: [BrowserModule],
precompile: [MainComponent],
providers: […], // additional providers
directives: […], // additional platform directives
pipes: […] // additional platform pipes
})
class MyModule {
constructor(appRef: ApplicationRef) {
appRef.bootstrap(MainComponent);
}
}
// offline compile
import {bootstrapModuleFactory} from ‘@angular/platform-browser’;
bootstrapModuleFactory(MyModuleNgFactory);
// runtime compile long form
import {bootstrapModule} from ‘@angular/platform-browser-dynamic’;
bootstrapModule(MyModule);
```
The short form, `bootstrap(...)`, can now creates a module on the fly,
given `directives`, `pipes, `providers`, `precompile` and `modules`
properties.
Related changes:
- make `SanitizationService`, `SecurityContext` public in `@angular/core` so that the offline compiler can resolve the token
- move `AnimationDriver` to `platform-browser` and make it
public so that the offline compiler can resolve the token
BREAKING CHANGES:
- short form bootstrap does no longer allow
to inject compiler internals (i.e. everything
from `@angular/compiler). Inject `Compiler` instead.
To provide custom providers for the compiler,
create a custom compiler via `browserCompiler({providers: [...]})`
and pass that into the `bootstrap` method.
2016-06-30 13:07:17 -07:00
* # # API ( version 2 )
* - ` appComponentType ` : The root component which should act as the application . This is
* a reference to a ` Type ` which is annotated with ` @Component(...) ` .
* - ` providers ` , ` directives ` , ` pipes ` , ` modules ` , ` precompile ` : Defines the properties
* of the dynamically created module that is used to bootstrap the module .
*
2016-06-10 10:21:53 -07:00
* Returns a ` Promise ` of { @link ComponentRef } .
2016-06-27 12:27:23 -07:00
*
* @experimental This api cannot be used with the offline compiler and thus is still subject to
* change .
2016-06-10 10:21:53 -07:00
* /
feat(browser): use AppModules for bootstrap in the browser
This introduces the `BrowserModule` to be used for long form
bootstrap and offline compile bootstrap:
```
@AppModule({
modules: [BrowserModule],
precompile: [MainComponent],
providers: […], // additional providers
directives: […], // additional platform directives
pipes: […] // additional platform pipes
})
class MyModule {
constructor(appRef: ApplicationRef) {
appRef.bootstrap(MainComponent);
}
}
// offline compile
import {bootstrapModuleFactory} from ‘@angular/platform-browser’;
bootstrapModuleFactory(MyModuleNgFactory);
// runtime compile long form
import {bootstrapModule} from ‘@angular/platform-browser-dynamic’;
bootstrapModule(MyModule);
```
The short form, `bootstrap(...)`, can now creates a module on the fly,
given `directives`, `pipes, `providers`, `precompile` and `modules`
properties.
Related changes:
- make `SanitizationService`, `SecurityContext` public in `@angular/core` so that the offline compiler can resolve the token
- move `AnimationDriver` to `platform-browser` and make it
public so that the offline compiler can resolve the token
BREAKING CHANGES:
- short form bootstrap does no longer allow
to inject compiler internals (i.e. everything
from `@angular/compiler). Inject `Compiler` instead.
To provide custom providers for the compiler,
create a custom compiler via `browserCompiler({providers: [...]})`
and pass that into the `bootstrap` method.
2016-06-30 13:07:17 -07:00
// Note: We are using typescript overloads here to have 2 function signatures!
export function bootstrap < C > (
appComponentType : ConcreteType < C > ,
customProviders? : Array < any /*Type | Provider | any[]*/ > ) : Promise < ComponentRef < C > > ;
export function bootstrap < C > (
appComponentType : ConcreteType < C > ,
{ providers , directives , pipes , modules , precompile , compiler } ? : {
providers? : Array < any /*Type | Provider | any[]*/ > ,
directives? : any [ ] ,
pipes? : any [ ] ,
modules? : any [ ] ,
precompile? : any [ ] ,
compiler? : Compiler
} ) : Promise < ComponentRef < C > > ;
export function bootstrap < C > (
appComponentType : ConcreteType < C > ,
customProvidersOrDynamicModule? : Array < any /*Type | Provider | any[]*/ > | {
providers : Array < any /*Type | Provider | any[]*/ > ,
directives : any [ ] ,
pipes : any [ ] ,
modules : any [ ] ,
precompile : any [ ] ,
compiler : Compiler
} ) : Promise < ComponentRef < C > > {
_initGlobals ( ) ;
let compiler : Compiler ;
let compilerProviders : any = [ ] ;
let providers : any [ ] = [ ] ;
let directives : any [ ] = [ ] ;
let pipes : any [ ] = [ ] ;
let modules : any [ ] = [ ] ;
let precompile : any [ ] = [ ] ;
if ( customProvidersOrDynamicModule instanceof Array ) {
providers = customProvidersOrDynamicModule ;
} else if ( customProvidersOrDynamicModule ) {
providers = normalizeArray ( customProvidersOrDynamicModule . providers ) ;
directives = normalizeArray ( customProvidersOrDynamicModule . directives ) ;
pipes = normalizeArray ( customProvidersOrDynamicModule . pipes ) ;
modules = normalizeArray ( customProvidersOrDynamicModule . modules ) ;
precompile = normalizeArray ( customProvidersOrDynamicModule . precompile ) ;
compiler = customProvidersOrDynamicModule . compiler ;
}
2016-07-07 14:42:46 -07:00
const deprecationMessages : string [ ] = [ ] ;
feat(browser): use AppModules for bootstrap in the browser
This introduces the `BrowserModule` to be used for long form
bootstrap and offline compile bootstrap:
```
@AppModule({
modules: [BrowserModule],
precompile: [MainComponent],
providers: […], // additional providers
directives: […], // additional platform directives
pipes: […] // additional platform pipes
})
class MyModule {
constructor(appRef: ApplicationRef) {
appRef.bootstrap(MainComponent);
}
}
// offline compile
import {bootstrapModuleFactory} from ‘@angular/platform-browser’;
bootstrapModuleFactory(MyModuleNgFactory);
// runtime compile long form
import {bootstrapModule} from ‘@angular/platform-browser-dynamic’;
bootstrapModule(MyModule);
```
The short form, `bootstrap(...)`, can now creates a module on the fly,
given `directives`, `pipes, `providers`, `precompile` and `modules`
properties.
Related changes:
- make `SanitizationService`, `SecurityContext` public in `@angular/core` so that the offline compiler can resolve the token
- move `AnimationDriver` to `platform-browser` and make it
public so that the offline compiler can resolve the token
BREAKING CHANGES:
- short form bootstrap does no longer allow
to inject compiler internals (i.e. everything
from `@angular/compiler). Inject `Compiler` instead.
To provide custom providers for the compiler,
create a custom compiler via `browserCompiler({providers: [...]})`
and pass that into the `bootstrap` method.
2016-06-30 13:07:17 -07:00
if ( providers && providers . length > 0 ) {
// Note: This is a hack to still support the old way
// of configuring platform directives / pipes and the compiler xhr.
// This will soon be deprecated!
2016-07-07 14:42:46 -07:00
const inj = ReflectiveInjector . resolveAndCreate ( providers ) ;
const compilerConfig : CompilerConfig = inj . get ( CompilerConfig , null ) ;
feat(browser): use AppModules for bootstrap in the browser
This introduces the `BrowserModule` to be used for long form
bootstrap and offline compile bootstrap:
```
@AppModule({
modules: [BrowserModule],
precompile: [MainComponent],
providers: […], // additional providers
directives: […], // additional platform directives
pipes: […] // additional platform pipes
})
class MyModule {
constructor(appRef: ApplicationRef) {
appRef.bootstrap(MainComponent);
}
}
// offline compile
import {bootstrapModuleFactory} from ‘@angular/platform-browser’;
bootstrapModuleFactory(MyModuleNgFactory);
// runtime compile long form
import {bootstrapModule} from ‘@angular/platform-browser-dynamic’;
bootstrapModule(MyModule);
```
The short form, `bootstrap(...)`, can now creates a module on the fly,
given `directives`, `pipes, `providers`, `precompile` and `modules`
properties.
Related changes:
- make `SanitizationService`, `SecurityContext` public in `@angular/core` so that the offline compiler can resolve the token
- move `AnimationDriver` to `platform-browser` and make it
public so that the offline compiler can resolve the token
BREAKING CHANGES:
- short form bootstrap does no longer allow
to inject compiler internals (i.e. everything
from `@angular/compiler). Inject `Compiler` instead.
To provide custom providers for the compiler,
create a custom compiler via `browserCompiler({providers: [...]})`
and pass that into the `bootstrap` method.
2016-06-30 13:07:17 -07:00
if ( compilerConfig ) {
// Note: forms read the platform directives / pipes, modify them
// and provide a CompilerConfig out of it
directives = directives . concat ( compilerConfig . platformDirectives ) ;
pipes = pipes . concat ( compilerConfig . platformPipes ) ;
2016-07-07 11:57:11 -07:00
deprecationMessages . push (
` Passing a CompilerConfig to "bootstrap()" as provider is deprecated. Pass the provider to "createCompiler()" and call "bootstrap()" with the created compiler instead. ` ) ;
feat(browser): use AppModules for bootstrap in the browser
This introduces the `BrowserModule` to be used for long form
bootstrap and offline compile bootstrap:
```
@AppModule({
modules: [BrowserModule],
precompile: [MainComponent],
providers: […], // additional providers
directives: […], // additional platform directives
pipes: […] // additional platform pipes
})
class MyModule {
constructor(appRef: ApplicationRef) {
appRef.bootstrap(MainComponent);
}
}
// offline compile
import {bootstrapModuleFactory} from ‘@angular/platform-browser’;
bootstrapModuleFactory(MyModuleNgFactory);
// runtime compile long form
import {bootstrapModule} from ‘@angular/platform-browser-dynamic’;
bootstrapModule(MyModule);
```
The short form, `bootstrap(...)`, can now creates a module on the fly,
given `directives`, `pipes, `providers`, `precompile` and `modules`
properties.
Related changes:
- make `SanitizationService`, `SecurityContext` public in `@angular/core` so that the offline compiler can resolve the token
- move `AnimationDriver` to `platform-browser` and make it
public so that the offline compiler can resolve the token
BREAKING CHANGES:
- short form bootstrap does no longer allow
to inject compiler internals (i.e. everything
from `@angular/compiler). Inject `Compiler` instead.
To provide custom providers for the compiler,
create a custom compiler via `browserCompiler({providers: [...]})`
and pass that into the `bootstrap` method.
2016-06-30 13:07:17 -07:00
} else {
// If nobody provided a CompilerConfig, use the
// PLATFORM_DIRECTIVES / PLATFORM_PIPES values directly.
2016-07-07 14:42:46 -07:00
const platformDirectives = inj . get ( PLATFORM_DIRECTIVES , [ ] ) ;
2016-07-07 11:57:11 -07:00
if ( platformDirectives . length > 0 ) {
deprecationMessages . push (
` Passing PLATFORM_DIRECTIVES to "bootstrap()" as provider is deprecated. Use the new parameter "directives" of "bootstrap()" instead. ` ) ;
}
directives = directives . concat ( platformDirectives ) ;
2016-07-07 14:42:46 -07:00
const platformPipes = inj . get ( PLATFORM_PIPES , [ ] ) ;
2016-07-07 11:57:11 -07:00
if ( platformPipes . length > 0 ) {
deprecationMessages . push (
` Passing PLATFORM_PIPES to "bootstrap()" as provider is deprecated. Use the new parameter "pipes" of "bootstrap()" instead. ` ) ;
}
pipes = pipes . concat ( platformPipes ) ;
feat(browser): use AppModules for bootstrap in the browser
This introduces the `BrowserModule` to be used for long form
bootstrap and offline compile bootstrap:
```
@AppModule({
modules: [BrowserModule],
precompile: [MainComponent],
providers: […], // additional providers
directives: […], // additional platform directives
pipes: […] // additional platform pipes
})
class MyModule {
constructor(appRef: ApplicationRef) {
appRef.bootstrap(MainComponent);
}
}
// offline compile
import {bootstrapModuleFactory} from ‘@angular/platform-browser’;
bootstrapModuleFactory(MyModuleNgFactory);
// runtime compile long form
import {bootstrapModule} from ‘@angular/platform-browser-dynamic’;
bootstrapModule(MyModule);
```
The short form, `bootstrap(...)`, can now creates a module on the fly,
given `directives`, `pipes, `providers`, `precompile` and `modules`
properties.
Related changes:
- make `SanitizationService`, `SecurityContext` public in `@angular/core` so that the offline compiler can resolve the token
- move `AnimationDriver` to `platform-browser` and make it
public so that the offline compiler can resolve the token
BREAKING CHANGES:
- short form bootstrap does no longer allow
to inject compiler internals (i.e. everything
from `@angular/compiler). Inject `Compiler` instead.
To provide custom providers for the compiler,
create a custom compiler via `browserCompiler({providers: [...]})`
and pass that into the `bootstrap` method.
2016-06-30 13:07:17 -07:00
}
2016-07-07 14:42:46 -07:00
const xhr = inj . get ( XHR , null ) ;
feat(browser): use AppModules for bootstrap in the browser
This introduces the `BrowserModule` to be used for long form
bootstrap and offline compile bootstrap:
```
@AppModule({
modules: [BrowserModule],
precompile: [MainComponent],
providers: […], // additional providers
directives: […], // additional platform directives
pipes: […] // additional platform pipes
})
class MyModule {
constructor(appRef: ApplicationRef) {
appRef.bootstrap(MainComponent);
}
}
// offline compile
import {bootstrapModuleFactory} from ‘@angular/platform-browser’;
bootstrapModuleFactory(MyModuleNgFactory);
// runtime compile long form
import {bootstrapModule} from ‘@angular/platform-browser-dynamic’;
bootstrapModule(MyModule);
```
The short form, `bootstrap(...)`, can now creates a module on the fly,
given `directives`, `pipes, `providers`, `precompile` and `modules`
properties.
Related changes:
- make `SanitizationService`, `SecurityContext` public in `@angular/core` so that the offline compiler can resolve the token
- move `AnimationDriver` to `platform-browser` and make it
public so that the offline compiler can resolve the token
BREAKING CHANGES:
- short form bootstrap does no longer allow
to inject compiler internals (i.e. everything
from `@angular/compiler). Inject `Compiler` instead.
To provide custom providers for the compiler,
create a custom compiler via `browserCompiler({providers: [...]})`
and pass that into the `bootstrap` method.
2016-06-30 13:07:17 -07:00
if ( xhr ) {
compilerProviders . push ( [ { provide : XHR , useValue : xhr } ] ) ;
2016-07-07 11:57:11 -07:00
deprecationMessages . push (
` Passing an instance of XHR to "bootstrap()" as provider is deprecated. Pass the provider to "createCompiler()" and call "bootstrap()" with the created compiler instead. ` ) ;
}
// Need to copy console from providers to compiler
// as well so that we can test the above deprecation messages!
2016-07-07 14:42:46 -07:00
const console = inj . get ( Console , null ) ;
2016-07-07 11:57:11 -07:00
if ( console ) {
compilerProviders . push ( [ { provide : Console , useValue : console } ] ) ;
feat(browser): use AppModules for bootstrap in the browser
This introduces the `BrowserModule` to be used for long form
bootstrap and offline compile bootstrap:
```
@AppModule({
modules: [BrowserModule],
precompile: [MainComponent],
providers: […], // additional providers
directives: […], // additional platform directives
pipes: […] // additional platform pipes
})
class MyModule {
constructor(appRef: ApplicationRef) {
appRef.bootstrap(MainComponent);
}
}
// offline compile
import {bootstrapModuleFactory} from ‘@angular/platform-browser’;
bootstrapModuleFactory(MyModuleNgFactory);
// runtime compile long form
import {bootstrapModule} from ‘@angular/platform-browser-dynamic’;
bootstrapModule(MyModule);
```
The short form, `bootstrap(...)`, can now creates a module on the fly,
given `directives`, `pipes, `providers`, `precompile` and `modules`
properties.
Related changes:
- make `SanitizationService`, `SecurityContext` public in `@angular/core` so that the offline compiler can resolve the token
- move `AnimationDriver` to `platform-browser` and make it
public so that the offline compiler can resolve the token
BREAKING CHANGES:
- short form bootstrap does no longer allow
to inject compiler internals (i.e. everything
from `@angular/compiler). Inject `Compiler` instead.
To provide custom providers for the compiler,
create a custom compiler via `browserCompiler({providers: [...]})`
and pass that into the `bootstrap` method.
2016-06-30 13:07:17 -07:00
}
}
if ( ! compiler ) {
compiler = browserCompiler ( { providers : compilerProviders } ) ;
}
2016-07-07 14:42:46 -07:00
const console : Console = compiler . injector . get ( Console ) ;
deprecationMessages . forEach ( ( msg ) = > { console . warn ( msg ) ; } ) ;
2016-06-10 10:21:53 -07:00
feat(browser): use AppModules for bootstrap in the browser
This introduces the `BrowserModule` to be used for long form
bootstrap and offline compile bootstrap:
```
@AppModule({
modules: [BrowserModule],
precompile: [MainComponent],
providers: […], // additional providers
directives: […], // additional platform directives
pipes: […] // additional platform pipes
})
class MyModule {
constructor(appRef: ApplicationRef) {
appRef.bootstrap(MainComponent);
}
}
// offline compile
import {bootstrapModuleFactory} from ‘@angular/platform-browser’;
bootstrapModuleFactory(MyModuleNgFactory);
// runtime compile long form
import {bootstrapModule} from ‘@angular/platform-browser-dynamic’;
bootstrapModule(MyModule);
```
The short form, `bootstrap(...)`, can now creates a module on the fly,
given `directives`, `pipes, `providers`, `precompile` and `modules`
properties.
Related changes:
- make `SanitizationService`, `SecurityContext` public in `@angular/core` so that the offline compiler can resolve the token
- move `AnimationDriver` to `platform-browser` and make it
public so that the offline compiler can resolve the token
BREAKING CHANGES:
- short form bootstrap does no longer allow
to inject compiler internals (i.e. everything
from `@angular/compiler). Inject `Compiler` instead.
To provide custom providers for the compiler,
create a custom compiler via `browserCompiler({providers: [...]})`
and pass that into the `bootstrap` method.
2016-06-30 13:07:17 -07:00
@AppModule ( {
providers : providers ,
modules : modules.concat ( [ BrowserModule ] ) ,
directives : directives ,
pipes : pipes ,
precompile : precompile.concat ( [ appComponentType ] )
} )
class DynamicModule {
constructor ( public appRef : ApplicationRef ) { }
}
return bootstrapModule ( DynamicModule , compiler )
. then (
( moduleRef ) = > moduleRef . instance . appRef . waitForAsyncInitializers ( ) . then (
( ) = > moduleRef . instance . appRef . bootstrap ( appComponentType ) ) ) ;
}
2016-06-10 10:21:53 -07:00
2016-06-15 17:12:22 -07:00
/ * *
* @experimental
* /
2016-06-15 08:25:31 -07:00
export function bootstrapWorkerUi (
2016-06-10 10:21:53 -07:00
workerScriptUri : string ,
customProviders? : Array < any /*Type | Provider | any[]*/ > ) : Promise < ApplicationRef > {
var app = ReflectiveInjector . resolveAndCreate (
[
2016-06-15 08:25:31 -07:00
WORKER_UI_APPLICATION_PROVIDERS , BROWSER_APP_COMPILER_PROVIDERS ,
2016-06-10 10:21:53 -07:00
{ provide : WORKER_SCRIPT , useValue : workerScriptUri } ,
isPresent ( customProviders ) ? customProviders : [ ]
] ,
2016-06-15 08:25:31 -07:00
workerUiPlatform ( ) . injector ) ;
2016-06-10 10:21:53 -07:00
// Return a promise so that we keep the same semantics as Dart,
// and we might want to wait for the app side to come up
// in the future...
return PromiseWrapper . resolve ( app . get ( ApplicationRef ) ) ;
}
2016-06-15 17:12:22 -07:00
/ * *
* @experimental
* /
2016-06-10 10:21:53 -07:00
const WORKER_APP_COMPILER_PROVIDERS : Array < any /*Type | Provider | any[]*/ > = [
2016-06-14 18:23:40 -07:00
COMPILER_PROVIDERS , {
2016-06-10 10:21:53 -07:00
provide : CompilerConfig ,
2016-06-14 18:23:40 -07:00
useFactory : ( platformDirectives : any [ ] , platformPipes : any [ ] ) = > {
return new CompilerConfig ( { platformDirectives , platformPipes } ) ;
} ,
deps : [ PLATFORM_DIRECTIVES , PLATFORM_PIPES ]
2016-06-10 10:21:53 -07:00
} ,
{ provide : XHR , useClass : XHRImpl } ,
2016-06-14 18:23:40 -07:00
{ provide : PLATFORM_DIRECTIVES , useValue : COMMON_DIRECTIVES , multi : true } ,
{ provide : PLATFORM_PIPES , useValue : COMMON_PIPES , multi : true }
2016-06-10 10:21:53 -07:00
] ;
2016-06-15 17:12:22 -07:00
/ * *
* @experimental
* /
2016-06-15 08:25:31 -07:00
export function bootstrapWorkerApp (
2016-06-10 10:21:53 -07:00
appComponentType : Type ,
customProviders? : Array < any /*Type | Provider | any[]*/ > ) : Promise < ComponentRef < any > > {
var appInjector = ReflectiveInjector . resolveAndCreate (
[
WORKER_APP_APPLICATION_PROVIDERS , WORKER_APP_COMPILER_PROVIDERS ,
isPresent ( customProviders ) ? customProviders : [ ]
] ,
workerAppPlatform ( ) . injector ) ;
return coreLoadAndBootstrap ( appComponentType , appInjector ) ;
}
feat(browser): use AppModules for bootstrap in the browser
This introduces the `BrowserModule` to be used for long form
bootstrap and offline compile bootstrap:
```
@AppModule({
modules: [BrowserModule],
precompile: [MainComponent],
providers: […], // additional providers
directives: […], // additional platform directives
pipes: […] // additional platform pipes
})
class MyModule {
constructor(appRef: ApplicationRef) {
appRef.bootstrap(MainComponent);
}
}
// offline compile
import {bootstrapModuleFactory} from ‘@angular/platform-browser’;
bootstrapModuleFactory(MyModuleNgFactory);
// runtime compile long form
import {bootstrapModule} from ‘@angular/platform-browser-dynamic’;
bootstrapModule(MyModule);
```
The short form, `bootstrap(...)`, can now creates a module on the fly,
given `directives`, `pipes, `providers`, `precompile` and `modules`
properties.
Related changes:
- make `SanitizationService`, `SecurityContext` public in `@angular/core` so that the offline compiler can resolve the token
- move `AnimationDriver` to `platform-browser` and make it
public so that the offline compiler can resolve the token
BREAKING CHANGES:
- short form bootstrap does no longer allow
to inject compiler internals (i.e. everything
from `@angular/compiler). Inject `Compiler` instead.
To provide custom providers for the compiler,
create a custom compiler via `browserCompiler({providers: [...]})`
and pass that into the `bootstrap` method.
2016-06-30 13:07:17 -07:00
function normalizeArray ( arr : any [ ] ) : any [ ] {
return arr ? arr : [ ] ;
}
