angular2
Version:
Angular 2 - a web framework for modern web apps
341 lines (340 loc) • 13.8 kB
JavaScript
var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
return c > 3 && r && Object.defineProperty(target, key, r), r;
};
var __metadata = (this && this.__metadata) || function (k, v) {
if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
};
import { NgZone } from 'angular2/src/core/zone/ng_zone';
import { isBlank, isPresent, assertionsEnabled, CONST_EXPR, lockMode, isPromise } from 'angular2/src/facade/lang';
import { Provider, Injector, Injectable } from 'angular2/src/core/di';
import { PLATFORM_INITIALIZER, APP_INITIALIZER } from './application_tokens';
import { PromiseWrapper, ObservableWrapper } from 'angular2/src/facade/async';
import { ListWrapper } from 'angular2/src/facade/collection';
import { TestabilityRegistry, Testability } from 'angular2/src/core/testability/testability';
import { ComponentResolver } from 'angular2/src/core/linker/component_resolver';
import { BaseException, ExceptionHandler, unimplemented } from 'angular2/src/facade/exceptions';
import { Console } from 'angular2/src/core/console';
import { wtfLeave, wtfCreateScope } from './profile/profile';
/**
* Create an Angular zone.
*/
export function createNgZone() {
return new NgZone({ enableLongStackTrace: assertionsEnabled() });
}
var _platform;
var _inPlatformCreate = false;
/**
* Creates a platform.
* Platforms have to be eagerly created via this function.
*/
export function createPlatform(injector) {
if (_inPlatformCreate) {
throw new BaseException('Already creating a platform...');
}
if (isPresent(_platform) && !_platform.disposed) {
throw new BaseException("There can be only one platform. Destroy the previous one to create a new one.");
}
lockMode();
_inPlatformCreate = true;
try {
_platform = injector.get(PlatformRef);
}
finally {
_inPlatformCreate = false;
}
return _platform;
}
/**
* Checks that there currently is a platform
* which contains the given token as a provider.
*/
export function assertPlatform(requiredToken) {
var platform = getPlatform();
if (isBlank(platform)) {
throw new BaseException('Not platform exists!');
}
if (isPresent(platform) && isBlank(platform.injector.get(requiredToken, null))) {
throw new BaseException('A platform with a different configuration has been created. Please destroy it first.');
}
return platform;
}
/**
* Dispose the existing platform.
*/
export function disposePlatform() {
if (isPresent(_platform) && !_platform.disposed) {
_platform.dispose();
}
}
/**
* Returns the current platform.
*/
export function getPlatform() {
return isPresent(_platform) && !_platform.disposed ? _platform : null;
}
/**
* Shortcut for ApplicationRef.bootstrap.
* Requires a platform the be created first.
*/
export function coreBootstrap(injector, componentFactory) {
var appRef = injector.get(ApplicationRef);
return appRef.bootstrap(componentFactory);
}
/**
* Resolves the componentFactory for the given component,
* waits for asynchronous initializers and bootstraps the component.
* Requires a platform the be created first.
*/
export function coreLoadAndBootstrap(injector, componentType) {
var appRef = injector.get(ApplicationRef);
return appRef.run(() => {
var componentResolver = injector.get(ComponentResolver);
return PromiseWrapper
.all([componentResolver.resolveComponent(componentType), appRef.waitForAsyncInitializers()])
.then((arr) => appRef.bootstrap(arr[0]));
});
}
/**
* The Angular platform is the entry point for Angular on a web page. Each page
* has exactly one platform, and services (such as reflection) which are common
* to every Angular application running on the page are bound in its scope.
*
* A page's platform is initialized implicitly when {@link bootstrap}() is called, or
* explicitly by calling {@link createPlatform}().
*/
export class PlatformRef {
/**
* Retrieve the platform {@link Injector}, which is the parent injector for
* every Angular application on the page and provides singleton providers.
*/
get injector() { throw unimplemented(); }
;
get disposed() { throw unimplemented(); }
}
export let PlatformRef_ = class PlatformRef_ extends PlatformRef {
constructor(_injector) {
super();
this._injector = _injector;
/** @internal */
this._applications = [];
/** @internal */
this._disposeListeners = [];
this._disposed = false;
if (!_inPlatformCreate) {
throw new BaseException('Platforms have to be created via `createPlatform`!');
}
let inits = _injector.get(PLATFORM_INITIALIZER, null);
if (isPresent(inits))
inits.forEach(init => init());
}
registerDisposeListener(dispose) { this._disposeListeners.push(dispose); }
get injector() { return this._injector; }
get disposed() { return this._disposed; }
addApplication(appRef) { this._applications.push(appRef); }
dispose() {
ListWrapper.clone(this._applications).forEach((app) => app.dispose());
this._disposeListeners.forEach((dispose) => dispose());
this._disposed = true;
}
/** @internal */
_applicationDisposed(app) { ListWrapper.remove(this._applications, app); }
};
PlatformRef_ = __decorate([
Injectable(),
__metadata('design:paramtypes', [Injector])
], PlatformRef_);
/**
* A reference to an Angular application running on a page.
*
* For more about Angular applications, see the documentation for {@link bootstrap}.
*/
export class ApplicationRef {
/**
* Retrieve the application {@link Injector}.
*/
get injector() { return unimplemented(); }
;
/**
* Retrieve the application {@link NgZone}.
*/
get zone() { return unimplemented(); }
;
/**
* Get a list of component types registered to this application.
*/
get componentTypes() { return unimplemented(); }
;
}
let ApplicationRef_1;
export let ApplicationRef_ = ApplicationRef_1 = class ApplicationRef_ extends ApplicationRef {
constructor(_platform, _zone, _injector) {
super();
this._platform = _platform;
this._zone = _zone;
this._injector = _injector;
/** @internal */
this._bootstrapListeners = [];
/** @internal */
this._disposeListeners = [];
/** @internal */
this._rootComponents = [];
/** @internal */
this._rootComponentTypes = [];
/** @internal */
this._changeDetectorRefs = [];
/** @internal */
this._runningTick = false;
/** @internal */
this._enforceNoNewChanges = false;
var zone = _injector.get(NgZone);
this._enforceNoNewChanges = assertionsEnabled();
zone.run(() => { this._exceptionHandler = _injector.get(ExceptionHandler); });
this._asyncInitDonePromise = this.run(() => {
let inits = _injector.get(APP_INITIALIZER, null);
var asyncInitResults = [];
var asyncInitDonePromise;
if (isPresent(inits)) {
for (var i = 0; i < inits.length; i++) {
var initResult = inits[i]();
if (isPromise(initResult)) {
asyncInitResults.push(initResult);
}
}
}
if (asyncInitResults.length > 0) {
asyncInitDonePromise =
PromiseWrapper.all(asyncInitResults).then((_) => this._asyncInitDone = true);
this._asyncInitDone = false;
}
else {
this._asyncInitDone = true;
asyncInitDonePromise = PromiseWrapper.resolve(true);
}
return asyncInitDonePromise;
});
ObservableWrapper.subscribe(zone.onError, (error) => {
this._exceptionHandler.call(error.error, error.stackTrace);
});
ObservableWrapper.subscribe(this._zone.onMicrotaskEmpty, (_) => { this._zone.run(() => { this.tick(); }); });
}
registerBootstrapListener(listener) {
this._bootstrapListeners.push(listener);
}
registerDisposeListener(dispose) { this._disposeListeners.push(dispose); }
registerChangeDetector(changeDetector) {
this._changeDetectorRefs.push(changeDetector);
}
unregisterChangeDetector(changeDetector) {
ListWrapper.remove(this._changeDetectorRefs, changeDetector);
}
waitForAsyncInitializers() { return this._asyncInitDonePromise; }
run(callback) {
var zone = this.injector.get(NgZone);
var result;
// Note: Don't use zone.runGuarded as we want to know about
// the thrown exception!
// Note: the completer needs to be created outside
// of `zone.run` as Dart swallows rejected promises
// via the onError callback of the promise.
var completer = PromiseWrapper.completer();
zone.run(() => {
try {
result = callback();
if (isPromise(result)) {
PromiseWrapper.then(result, (ref) => { completer.resolve(ref); }, (err, stackTrace) => {
completer.reject(err, stackTrace);
this._exceptionHandler.call(err, stackTrace);
});
}
}
catch (e) {
this._exceptionHandler.call(e, e.stack);
throw e;
}
});
return isPromise(result) ? completer.promise : result;
}
bootstrap(componentFactory) {
if (!this._asyncInitDone) {
throw new BaseException('Cannot bootstrap as there are still asynchronous initializers running. Wait for them using waitForAsyncInitializers().');
}
return this.run(() => {
this._rootComponentTypes.push(componentFactory.componentType);
var compRef = componentFactory.create(this._injector, [], componentFactory.selector);
compRef.onDestroy(() => { this._unloadComponent(compRef); });
var testability = compRef.injector.get(Testability, null);
if (isPresent(testability)) {
compRef.injector.get(TestabilityRegistry)
.registerApplication(compRef.location.nativeElement, testability);
}
this._loadComponent(compRef);
let c = this._injector.get(Console);
if (assertionsEnabled()) {
c.log("Angular 2 is running in the development mode. Call enableProdMode() to enable the production mode.");
}
return compRef;
});
}
/** @internal */
_loadComponent(componentRef) {
this._changeDetectorRefs.push(componentRef.changeDetectorRef);
this.tick();
this._rootComponents.push(componentRef);
this._bootstrapListeners.forEach((listener) => listener(componentRef));
}
/** @internal */
_unloadComponent(componentRef) {
if (!ListWrapper.contains(this._rootComponents, componentRef)) {
return;
}
this.unregisterChangeDetector(componentRef.changeDetectorRef);
ListWrapper.remove(this._rootComponents, componentRef);
}
get injector() { return this._injector; }
get zone() { return this._zone; }
tick() {
if (this._runningTick) {
throw new BaseException("ApplicationRef.tick is called recursively");
}
var s = ApplicationRef_1._tickScope();
try {
this._runningTick = true;
this._changeDetectorRefs.forEach((detector) => detector.detectChanges());
if (this._enforceNoNewChanges) {
this._changeDetectorRefs.forEach((detector) => detector.checkNoChanges());
}
}
finally {
this._runningTick = false;
wtfLeave(s);
}
}
dispose() {
// TODO(alxhub): Dispose of the NgZone.
ListWrapper.clone(this._rootComponents).forEach((ref) => ref.destroy());
this._disposeListeners.forEach((dispose) => dispose());
this._platform._applicationDisposed(this);
}
get componentTypes() { return this._rootComponentTypes; }
};
/** @internal */
ApplicationRef_._tickScope = wtfCreateScope('ApplicationRef#tick()');
ApplicationRef_ = ApplicationRef_1 = __decorate([
Injectable(),
__metadata('design:paramtypes', [PlatformRef_, NgZone, Injector])
], ApplicationRef_);
/**
* @internal
*/
export const PLATFORM_CORE_PROVIDERS = CONST_EXPR([PlatformRef_, CONST_EXPR(new Provider(PlatformRef, { useExisting: PlatformRef_ }))]);
/**
* @internal
*/
export const APPLICATION_CORE_PROVIDERS = CONST_EXPR([
CONST_EXPR(new Provider(NgZone, { useFactory: createNgZone, deps: CONST_EXPR([]) })),
ApplicationRef_,
CONST_EXPR(new Provider(ApplicationRef, { useExisting: ApplicationRef_ }))
]);