@angular/core
Version:
Angular - the core framework
553 lines • 45.4 kB
JavaScript
/**
* @fileoverview added by tsickle
* Generated from: packages/core/src/zone/ng_zone.ts
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* @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
*/
import { EventEmitter } from '../event_emitter';
import { global } from '../util/global';
import { getNativeRequestAnimationFrame } from '../util/raf';
/**
* An injectable service for executing work inside or outside of the Angular zone.
*
* The most common use of this service is to optimize performance when starting a work consisting of
* one or more asynchronous tasks that don't require UI updates or error handling to be handled by
* Angular. Such tasks can be kicked off via {\@link #runOutsideAngular} and if needed, these tasks
* can reenter the Angular zone via {\@link #run}.
*
* <!-- TODO: add/fix links to:
* - docs explaining zones and the use of zones in Angular and change-detection
* - link to runOutsideAngular/run (throughout this file!)
* -->
*
* \@usageNotes
* ### Example
*
* ```
* import {Component, NgZone} from '\@angular/core';
* import {NgIf} from '\@angular/common';
*
* \@Component({
* selector: 'ng-zone-demo',
* template: `
* <h2>Demo: NgZone</h2>
*
* <p>Progress: {{progress}}%</p>
* <p *ngIf="progress >= 100">Done processing {{label}} of Angular zone!</p>
*
* <button (click)="processWithinAngularZone()">Process within Angular zone</button>
* <button (click)="processOutsideOfAngularZone()">Process outside of Angular zone</button>
* `,
* })
* export class NgZoneDemo {
* progress: number = 0;
* label: string;
*
* constructor(private _ngZone: NgZone) {}
*
* // Loop inside the Angular zone
* // so the UI DOES refresh after each setTimeout cycle
* processWithinAngularZone() {
* this.label = 'inside';
* this.progress = 0;
* this._increaseProgress(() => console.log('Inside Done!'));
* }
*
* // Loop outside of the Angular zone
* // so the UI DOES NOT refresh after each setTimeout cycle
* processOutsideOfAngularZone() {
* this.label = 'outside';
* this.progress = 0;
* this._ngZone.runOutsideAngular(() => {
* this._increaseProgress(() => {
* // reenter the Angular zone and display done
* this._ngZone.run(() => { console.log('Outside Done!'); });
* });
* });
* }
*
* _increaseProgress(doneCallback: () => void) {
* this.progress += 1;
* console.log(`Current progress: ${this.progress}%`);
*
* if (this.progress < 100) {
* window.setTimeout(() => this._increaseProgress(doneCallback), 10);
* } else {
* doneCallback();
* }
* }
* }
* ```
*
* \@publicApi
*/
export class NgZone {
/**
* @param {?} __0
*/
constructor({ enableLongStackTrace = false, shouldCoalesceEventChangeDetection = false }) {
this.hasPendingMacrotasks = false;
this.hasPendingMicrotasks = false;
/**
* Whether there are no outstanding microtasks or macrotasks.
*/
this.isStable = true;
/**
* Notifies when code enters Angular Zone. This gets fired first on VM Turn.
*/
this.onUnstable = new EventEmitter(false);
/**
* Notifies when there is no more microtasks enqueued in the current VM Turn.
* This is a hint for Angular to do change detection, which may enqueue more microtasks.
* For this reason this event can fire multiple times per VM Turn.
*/
this.onMicrotaskEmpty = new EventEmitter(false);
/**
* Notifies when the last `onMicrotaskEmpty` has run and there are no more microtasks, which
* implies we are about to relinquish VM turn.
* This event gets called just once.
*/
this.onStable = new EventEmitter(false);
/**
* Notifies that an error has been delivered.
*/
this.onError = new EventEmitter(false);
if (typeof Zone == 'undefined') {
throw new Error(`In this configuration Angular requires Zone.js`);
}
Zone.assertZonePatched();
/** @type {?} */
const self = (/** @type {?} */ ((/** @type {?} */ (this))));
self._nesting = 0;
self._outer = self._inner = Zone.current;
if (((/** @type {?} */ (Zone)))['wtfZoneSpec']) {
self._inner = self._inner.fork(((/** @type {?} */ (Zone)))['wtfZoneSpec']);
}
if (((/** @type {?} */ (Zone)))['TaskTrackingZoneSpec']) {
self._inner = self._inner.fork(new ((/** @type {?} */ (((/** @type {?} */ (Zone)))['TaskTrackingZoneSpec']))));
}
if (enableLongStackTrace && ((/** @type {?} */ (Zone)))['longStackTraceZoneSpec']) {
self._inner = self._inner.fork(((/** @type {?} */ (Zone)))['longStackTraceZoneSpec']);
}
self.shouldCoalesceEventChangeDetection = shouldCoalesceEventChangeDetection;
self.lastRequestAnimationFrameId = -1;
self.nativeRequestAnimationFrame = getNativeRequestAnimationFrame().nativeRequestAnimationFrame;
forkInnerZoneWithAngularBehavior(self);
}
/**
* @return {?}
*/
static isInAngularZone() {
return Zone.current.get('isAngularZone') === true;
}
/**
* @return {?}
*/
static assertInAngularZone() {
if (!NgZone.isInAngularZone()) {
throw new Error('Expected to be in Angular Zone, but it is not!');
}
}
/**
* @return {?}
*/
static assertNotInAngularZone() {
if (NgZone.isInAngularZone()) {
throw new Error('Expected to not be in Angular Zone, but it is!');
}
}
/**
* Executes the `fn` function synchronously within the Angular zone and returns value returned by
* the function.
*
* Running functions via `run` allows you to reenter Angular zone from a task that was executed
* outside of the Angular zone (typically started via {\@link #runOutsideAngular}).
*
* Any future tasks or microtasks scheduled from within this function will continue executing from
* within the Angular zone.
*
* If a synchronous error happens it will be rethrown and not reported via `onError`.
* @template T
* @param {?} fn
* @param {?=} applyThis
* @param {?=} applyArgs
* @return {?}
*/
run(fn, applyThis, applyArgs) {
return (/** @type {?} */ (((/** @type {?} */ ((/** @type {?} */ (this)))))._inner.run(fn, applyThis, applyArgs)));
}
/**
* Executes the `fn` function synchronously within the Angular zone as a task and returns value
* returned by the function.
*
* Running functions via `run` allows you to reenter Angular zone from a task that was executed
* outside of the Angular zone (typically started via {\@link #runOutsideAngular}).
*
* Any future tasks or microtasks scheduled from within this function will continue executing from
* within the Angular zone.
*
* If a synchronous error happens it will be rethrown and not reported via `onError`.
* @template T
* @param {?} fn
* @param {?=} applyThis
* @param {?=} applyArgs
* @param {?=} name
* @return {?}
*/
runTask(fn, applyThis, applyArgs, name) {
/** @type {?} */
const zone = ((/** @type {?} */ ((/** @type {?} */ (this)))))._inner;
/** @type {?} */
const task = zone.scheduleEventTask('NgZoneEvent: ' + name, fn, EMPTY_PAYLOAD, noop, noop);
try {
return (/** @type {?} */ (zone.runTask(task, applyThis, applyArgs)));
}
finally {
zone.cancelTask(task);
}
}
/**
* Same as `run`, except that synchronous errors are caught and forwarded via `onError` and not
* rethrown.
* @template T
* @param {?} fn
* @param {?=} applyThis
* @param {?=} applyArgs
* @return {?}
*/
runGuarded(fn, applyThis, applyArgs) {
return (/** @type {?} */ (((/** @type {?} */ ((/** @type {?} */ (this)))))._inner.runGuarded(fn, applyThis, applyArgs)));
}
/**
* Executes the `fn` function synchronously in Angular's parent zone and returns value returned by
* the function.
*
* Running functions via {\@link #runOutsideAngular} allows you to escape Angular's zone and do
* work that
* doesn't trigger Angular change-detection or is subject to Angular's error handling.
*
* Any future tasks or microtasks scheduled from within this function will continue executing from
* outside of the Angular zone.
*
* Use {\@link #run} to reenter the Angular zone and do work that updates the application model.
* @template T
* @param {?} fn
* @return {?}
*/
runOutsideAngular(fn) {
return (/** @type {?} */ (((/** @type {?} */ ((/** @type {?} */ (this)))))._outer.run(fn)));
}
}
if (false) {
/** @type {?} */
NgZone.prototype.hasPendingMacrotasks;
/** @type {?} */
NgZone.prototype.hasPendingMicrotasks;
/**
* Whether there are no outstanding microtasks or macrotasks.
* @type {?}
*/
NgZone.prototype.isStable;
/**
* Notifies when code enters Angular Zone. This gets fired first on VM Turn.
* @type {?}
*/
NgZone.prototype.onUnstable;
/**
* Notifies when there is no more microtasks enqueued in the current VM Turn.
* This is a hint for Angular to do change detection, which may enqueue more microtasks.
* For this reason this event can fire multiple times per VM Turn.
* @type {?}
*/
NgZone.prototype.onMicrotaskEmpty;
/**
* Notifies when the last `onMicrotaskEmpty` has run and there are no more microtasks, which
* implies we are about to relinquish VM turn.
* This event gets called just once.
* @type {?}
*/
NgZone.prototype.onStable;
/**
* Notifies that an error has been delivered.
* @type {?}
*/
NgZone.prototype.onError;
}
/**
* @return {?}
*/
function noop() { }
/** @type {?} */
const EMPTY_PAYLOAD = {};
/**
* @record
*/
function NgZonePrivate() { }
if (false) {
/** @type {?} */
NgZonePrivate.prototype._outer;
/** @type {?} */
NgZonePrivate.prototype._inner;
/** @type {?} */
NgZonePrivate.prototype._nesting;
/** @type {?} */
NgZonePrivate.prototype._hasPendingMicrotasks;
/** @type {?} */
NgZonePrivate.prototype.hasPendingMacrotasks;
/** @type {?} */
NgZonePrivate.prototype.hasPendingMicrotasks;
/** @type {?} */
NgZonePrivate.prototype.lastRequestAnimationFrameId;
/** @type {?} */
NgZonePrivate.prototype.isStable;
/** @type {?} */
NgZonePrivate.prototype.shouldCoalesceEventChangeDetection;
/** @type {?} */
NgZonePrivate.prototype.nativeRequestAnimationFrame;
}
/**
* @param {?} zone
* @return {?}
*/
function checkStable(zone) {
if (zone._nesting == 0 && !zone.hasPendingMicrotasks && !zone.isStable) {
try {
zone._nesting++;
zone.onMicrotaskEmpty.emit(null);
}
finally {
zone._nesting--;
if (!zone.hasPendingMicrotasks) {
try {
zone.runOutsideAngular((/**
* @return {?}
*/
() => zone.onStable.emit(null)));
}
finally {
zone.isStable = true;
}
}
}
}
}
/**
* @param {?} zone
* @return {?}
*/
function delayChangeDetectionForEvents(zone) {
if (zone.lastRequestAnimationFrameId !== -1) {
return;
}
zone.lastRequestAnimationFrameId = zone.nativeRequestAnimationFrame.call(global, (/**
* @return {?}
*/
() => {
zone.lastRequestAnimationFrameId = -1;
updateMicroTaskStatus(zone);
checkStable(zone);
}));
updateMicroTaskStatus(zone);
}
/**
* @param {?} zone
* @return {?}
*/
function forkInnerZoneWithAngularBehavior(zone) {
/** @type {?} */
const delayChangeDetectionForEventsDelegate = (/**
* @return {?}
*/
() => {
delayChangeDetectionForEvents(zone);
});
/** @type {?} */
const maybeDelayChangeDetection = !!zone.shouldCoalesceEventChangeDetection &&
zone.nativeRequestAnimationFrame && delayChangeDetectionForEventsDelegate;
zone._inner = zone._inner.fork({
name: 'angular',
properties: (/** @type {?} */ ({ 'isAngularZone': true, 'maybeDelayChangeDetection': maybeDelayChangeDetection })),
onInvokeTask: (/**
* @param {?} delegate
* @param {?} current
* @param {?} target
* @param {?} task
* @param {?} applyThis
* @param {?} applyArgs
* @return {?}
*/
(delegate, current, target, task, applyThis, applyArgs) => {
try {
onEnter(zone);
return delegate.invokeTask(target, task, applyThis, applyArgs);
}
finally {
if (maybeDelayChangeDetection && task.type === 'eventTask') {
maybeDelayChangeDetection();
}
onLeave(zone);
}
}),
onInvoke: (/**
* @param {?} delegate
* @param {?} current
* @param {?} target
* @param {?} callback
* @param {?} applyThis
* @param {?=} applyArgs
* @param {?=} source
* @return {?}
*/
(delegate, current, target, callback, applyThis, applyArgs, source) => {
try {
onEnter(zone);
return delegate.invoke(target, callback, applyThis, applyArgs, source);
}
finally {
onLeave(zone);
}
}),
onHasTask: (/**
* @param {?} delegate
* @param {?} current
* @param {?} target
* @param {?} hasTaskState
* @return {?}
*/
(delegate, current, target, hasTaskState) => {
delegate.hasTask(target, hasTaskState);
if (current === target) {
// We are only interested in hasTask events which originate from our zone
// (A child hasTask event is not interesting to us)
if (hasTaskState.change == 'microTask') {
zone._hasPendingMicrotasks = hasTaskState.microTask;
updateMicroTaskStatus(zone);
checkStable(zone);
}
else if (hasTaskState.change == 'macroTask') {
zone.hasPendingMacrotasks = hasTaskState.macroTask;
}
}
}),
onHandleError: (/**
* @param {?} delegate
* @param {?} current
* @param {?} target
* @param {?} error
* @return {?}
*/
(delegate, current, target, error) => {
delegate.handleError(target, error);
zone.runOutsideAngular((/**
* @return {?}
*/
() => zone.onError.emit(error)));
return false;
})
});
}
/**
* @param {?} zone
* @return {?}
*/
function updateMicroTaskStatus(zone) {
if (zone._hasPendingMicrotasks ||
(zone.shouldCoalesceEventChangeDetection && zone.lastRequestAnimationFrameId !== -1)) {
zone.hasPendingMicrotasks = true;
}
else {
zone.hasPendingMicrotasks = false;
}
}
/**
* @param {?} zone
* @return {?}
*/
function onEnter(zone) {
zone._nesting++;
if (zone.isStable) {
zone.isStable = false;
zone.onUnstable.emit(null);
}
}
/**
* @param {?} zone
* @return {?}
*/
function onLeave(zone) {
zone._nesting--;
checkStable(zone);
}
/**
* Provides a noop implementation of `NgZone` which does nothing. This zone requires explicit calls
* to framework to perform rendering.
*/
export class NoopNgZone {
constructor() {
this.hasPendingMicrotasks = false;
this.hasPendingMacrotasks = false;
this.isStable = true;
this.onUnstable = new EventEmitter();
this.onMicrotaskEmpty = new EventEmitter();
this.onStable = new EventEmitter();
this.onError = new EventEmitter();
}
/**
* @param {?} fn
* @param {?=} applyThis
* @param {?=} applyArgs
* @return {?}
*/
run(fn, applyThis, applyArgs) {
return fn.apply(applyThis, applyArgs);
}
/**
* @param {?} fn
* @param {?=} applyThis
* @param {?=} applyArgs
* @return {?}
*/
runGuarded(fn, applyThis, applyArgs) {
return fn.apply(applyThis, applyArgs);
}
/**
* @param {?} fn
* @return {?}
*/
runOutsideAngular(fn) {
return fn();
}
/**
* @param {?} fn
* @param {?=} applyThis
* @param {?=} applyArgs
* @param {?=} name
* @return {?}
*/
runTask(fn, applyThis, applyArgs, name) {
return fn.apply(applyThis, applyArgs);
}
}
if (false) {
/** @type {?} */
NoopNgZone.prototype.hasPendingMicrotasks;
/** @type {?} */
NoopNgZone.prototype.hasPendingMacrotasks;
/** @type {?} */
NoopNgZone.prototype.isStable;
/** @type {?} */
NoopNgZone.prototype.onUnstable;
/** @type {?} */
NoopNgZone.prototype.onMicrotaskEmpty;
/** @type {?} */
NoopNgZone.prototype.onStable;
/** @type {?} */
NoopNgZone.prototype.onError;
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ng_zone.js","sourceRoot":"","sources":["../../../../../../../packages/core/src/zone/ng_zone.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {EventEmitter} from '../event_emitter';\nimport {global} from '../util/global';\nimport {getNativeRequestAnimationFrame} from '../util/raf';\n\n\n/**\n * An injectable service for executing work inside or outside of the Angular zone.\n *\n * The most common use of this service is to optimize performance when starting a work consisting of\n * one or more asynchronous tasks that don't require UI updates or error handling to be handled by\n * Angular. Such tasks can be kicked off via {@link #runOutsideAngular} and if needed, these tasks\n * can reenter the Angular zone via {@link #run}.\n *\n * <!-- TODO: add/fix links to:\n *   - docs explaining zones and the use of zones in Angular and change-detection\n *   - link to runOutsideAngular/run (throughout this file!)\n *   -->\n *\n * @usageNotes\n * ### Example\n *\n * ```\n * import {Component, NgZone} from '@angular/core';\n * import {NgIf} from '@angular/common';\n *\n * @Component({\n *   selector: 'ng-zone-demo',\n *   template: `\n *     <h2>Demo: NgZone</h2>\n *\n *     <p>Progress: {{progress}}%</p>\n *     <p *ngIf=\"progress >= 100\">Done processing {{label}} of Angular zone!</p>\n *\n *     <button (click)=\"processWithinAngularZone()\">Process within Angular zone</button>\n *     <button (click)=\"processOutsideOfAngularZone()\">Process outside of Angular zone</button>\n *   `,\n * })\n * export class NgZoneDemo {\n *   progress: number = 0;\n *   label: string;\n *\n *   constructor(private _ngZone: NgZone) {}\n *\n *   // Loop inside the Angular zone\n *   // so the UI DOES refresh after each setTimeout cycle\n *   processWithinAngularZone() {\n *     this.label = 'inside';\n *     this.progress = 0;\n *     this._increaseProgress(() => console.log('Inside Done!'));\n *   }\n *\n *   // Loop outside of the Angular zone\n *   // so the UI DOES NOT refresh after each setTimeout cycle\n *   processOutsideOfAngularZone() {\n *     this.label = 'outside';\n *     this.progress = 0;\n *     this._ngZone.runOutsideAngular(() => {\n *       this._increaseProgress(() => {\n *         // reenter the Angular zone and display done\n *         this._ngZone.run(() => { console.log('Outside Done!'); });\n *       });\n *     });\n *   }\n *\n *   _increaseProgress(doneCallback: () => void) {\n *     this.progress += 1;\n *     console.log(`Current progress: ${this.progress}%`);\n *\n *     if (this.progress < 100) {\n *       window.setTimeout(() => this._increaseProgress(doneCallback), 10);\n *     } else {\n *       doneCallback();\n *     }\n *   }\n * }\n * ```\n *\n * @publicApi\n */\nexport class NgZone {\n  readonly hasPendingMacrotasks: boolean = false;\n  readonly hasPendingMicrotasks: boolean = false;\n\n  /**\n   * Whether there are no outstanding microtasks or macrotasks.\n   */\n  readonly isStable: boolean = true;\n\n  /**\n   * Notifies when code enters Angular Zone. This gets fired first on VM Turn.\n   */\n  readonly onUnstable: EventEmitter<any> = new EventEmitter(false);\n\n  /**\n   * Notifies when there is no more microtasks enqueued in the current VM Turn.\n   * This is a hint for Angular to do change detection, which may enqueue more microtasks.\n   * For this reason this event can fire multiple times per VM Turn.\n   */\n  readonly onMicrotaskEmpty: EventEmitter<any> = new EventEmitter(false);\n\n  /**\n   * Notifies when the last `onMicrotaskEmpty` has run and there are no more microtasks, which\n   * implies we are about to relinquish VM turn.\n   * This event gets called just once.\n   */\n  readonly onStable: EventEmitter<any> = new EventEmitter(false);\n\n  /**\n   * Notifies that an error has been delivered.\n   */\n  readonly onError: EventEmitter<any> = new EventEmitter(false);\n\n\n  constructor({enableLongStackTrace = false, shouldCoalesceEventChangeDetection = false}) {\n    if (typeof Zone == 'undefined') {\n      throw new Error(`In this configuration Angular requires Zone.js`);\n    }\n\n    Zone.assertZonePatched();\n    const self = this as any as NgZonePrivate;\n    self._nesting = 0;\n\n    self._outer = self._inner = Zone.current;\n\n    if ((Zone as any)['wtfZoneSpec']) {\n      self._inner = self._inner.fork((Zone as any)['wtfZoneSpec']);\n    }\n\n    if ((Zone as any)['TaskTrackingZoneSpec']) {\n      self._inner = self._inner.fork(new ((Zone as any)['TaskTrackingZoneSpec'] as any));\n    }\n\n    if (enableLongStackTrace && (Zone as any)['longStackTraceZoneSpec']) {\n      self._inner = self._inner.fork((Zone as any)['longStackTraceZoneSpec']);\n    }\n\n    self.shouldCoalesceEventChangeDetection = shouldCoalesceEventChangeDetection;\n    self.lastRequestAnimationFrameId = -1;\n    self.nativeRequestAnimationFrame = getNativeRequestAnimationFrame().nativeRequestAnimationFrame;\n    forkInnerZoneWithAngularBehavior(self);\n  }\n\n  static isInAngularZone(): boolean {\n    return Zone.current.get('isAngularZone') === true;\n  }\n\n  static assertInAngularZone(): void {\n    if (!NgZone.isInAngularZone()) {\n      throw new Error('Expected to be in Angular Zone, but it is not!');\n    }\n  }\n\n  static assertNotInAngularZone(): void {\n    if (NgZone.isInAngularZone()) {\n      throw new Error('Expected to not be in Angular Zone, but it is!');\n    }\n  }\n\n  /**\n   * Executes the `fn` function synchronously within the Angular zone and returns value returned by\n   * the function.\n   *\n   * Running functions via `run` allows you to reenter Angular zone from a task that was executed\n   * outside of the Angular zone (typically started via {@link #runOutsideAngular}).\n   *\n   * Any future tasks or microtasks scheduled from within this function will continue executing from\n   * within the Angular zone.\n   *\n   * If a synchronous error happens it will be rethrown and not reported via `onError`.\n   */\n  run<T>(fn: (...args: any[]) => T, applyThis?: any, applyArgs?: any[]): T {\n    return (this as any as NgZonePrivate)._inner.run(fn, applyThis, applyArgs) as T;\n  }\n\n  /**\n   * Executes the `fn` function synchronously within the Angular zone as a task and returns value\n   * returned by the function.\n   *\n   * Running functions via `run` allows you to reenter Angular zone from a task that was executed\n   * outside of the Angular zone (typically started via {@link #runOutsideAngular}).\n   *\n   * Any future tasks or microtasks scheduled from within this function will continue executing from\n   * within the Angular zone.\n   *\n   * If a synchronous error happens it will be rethrown and not reported via `onError`.\n   */\n  runTask<T>(fn: (...args: any[]) => T, applyThis?: any, applyArgs?: any[], name?: string): T {\n    const zone = (this as any as NgZonePrivate)._inner;\n    const task = zone.scheduleEventTask('NgZoneEvent: ' + name, fn, EMPTY_PAYLOAD, noop, noop);\n    try {\n      return zone.runTask(task, applyThis, applyArgs) as T;\n    } finally {\n      zone.cancelTask(task);\n    }\n  }\n\n  /**\n   * Same as `run`, except that synchronous errors are caught and forwarded via `onError` and not\n   * rethrown.\n   */\n  runGuarded<T>(fn: (...args: any[]) => T, applyThis?: any, applyArgs?: any[]): T {\n    return (this as any as NgZonePrivate)._inner.runGuarded(fn, applyThis, applyArgs) as T;\n  }\n\n  /**\n   * Executes the `fn` function synchronously in Angular's parent zone and returns value returned by\n   * the function.\n   *\n   * Running functions via {@link #runOutsideAngular} allows you to escape Angular's zone and do\n   * work that\n   * doesn't trigger Angular change-detection or is subject to Angular's error handling.\n   *\n   * Any future tasks or microtasks scheduled from within this function will continue executing from\n   * outside of the Angular zone.\n   *\n   * Use {@link #run} to reenter the Angular zone and do work that updates the application model.\n   */\n  runOutsideAngular<T>(fn: (...args: any[]) => T): T {\n    return (this as any as NgZonePrivate)._outer.run(fn) as T;\n  }\n}\n\nfunction noop() {}\nconst EMPTY_PAYLOAD = {};\n\ninterface NgZonePrivate extends NgZone {\n  _outer: Zone;\n  _inner: Zone;\n  _nesting: number;\n  _hasPendingMicrotasks: boolean;\n\n  hasPendingMacrotasks: boolean;\n  hasPendingMicrotasks: boolean;\n  lastRequestAnimationFrameId: number;\n  isStable: boolean;\n  shouldCoalesceEventChangeDetection: boolean;\n  nativeRequestAnimationFrame: (callback: FrameRequestCallback) => number;\n}\n\nfunction checkStable(zone: NgZonePrivate) {\n  if (zone._nesting == 0 && !zone.hasPendingMicrotasks && !zone.isStable) {\n    try {\n      zone._nesting++;\n      zone.onMicrotaskEmpty.emit(null);\n    } finally {\n      zone._nesting--;\n      if (!zone.hasPendingMicrotasks) {\n        try {\n          zone.runOutsideAngular(() => zone.onStable.emit(null));\n        } finally {\n          zone.isStable = true;\n        }\n      }\n    }\n  }\n}\n\nfunction delayChangeDetectionForEvents(zone: NgZonePrivate) {\n  if (zone.lastRequestAnimationFrameId !== -1) {\n    return;\n  }\n  zone.lastRequestAnimationFrameId = zone.nativeRequestAnimationFrame.call(global, () => {\n    zone.lastRequestAnimationFrameId = -1;\n    updateMicroTaskStatus(zone);\n    checkStable(zone);\n  });\n  updateMicroTaskStatus(zone);\n}\n\nfunction forkInnerZoneWithAngularBehavior(zone: NgZonePrivate) {\n  const delayChangeDetectionForEventsDelegate = () => {\n    delayChangeDetectionForEvents(zone);\n  };\n  const maybeDelayChangeDetection = !!zone.shouldCoalesceEventChangeDetection &&\n      zone.nativeRequestAnimationFrame && delayChangeDetectionForEventsDelegate;\n  zone._inner = zone._inner.fork({\n    name: 'angular',\n    properties:\n        <any>{'isAngularZone': true, 'maybeDelayChangeDetection': maybeDelayChangeDetection},\n    onInvokeTask:\n        (delegate: ZoneDelegate, current: Zone, target: Zone, task: Task, applyThis: any,\n         applyArgs: any): any => {\n          try {\n            onEnter(zone);\n            return delegate.invokeTask(target, task, applyThis, applyArgs);\n          } finally {\n            if (maybeDelayChangeDetection && task.type === 'eventTask') {\n              maybeDelayChangeDetection();\n            }\n            onLeave(zone);\n          }\n        },\n\n\n    onInvoke:\n        (delegate: ZoneDelegate, current: Zone, target: Zone, callback: Function, applyThis: any,\n         applyArgs?: any[], source?: string): any => {\n          try {\n            onEnter(zone);\n            return delegate.invoke(target, callback, applyThis, applyArgs, source);\n          } finally {\n            onLeave(zone);\n          }\n        },\n\n    onHasTask:\n        (delegate: ZoneDelegate, current: Zone, target: Zone, hasTaskState: HasTaskState) => {\n          delegate.hasTask(target, hasTaskState);\n          if (current === target) {\n            // We are only interested in hasTask events which originate from our zone\n            // (A child hasTask event is not interesting to us)\n            if (hasTaskState.change == 'microTask') {\n              zone._hasPendingMicrotasks = hasTaskState.microTask;\n              updateMicroTaskStatus(zone);\n              checkStable(zone);\n            } else if (hasTaskState.change == 'macroTask') {\n              zone.hasPendingMacrotasks = hasTaskState.macroTask;\n            }\n          }\n        },\n\n    onHandleError: (delegate: ZoneDelegate, current: Zone, target: Zone, error: any): boolean => {\n      delegate.handleError(target, error);\n      zone.runOutsideAngular(() => zone.onError.emit(error));\n      return false;\n    }\n  });\n}\n\nfunction updateMicroTaskStatus(zone: NgZonePrivate) {\n  if (zone._hasPendingMicrotasks ||\n      (zone.shouldCoalesceEventChangeDetection && zone.lastRequestAnimationFrameId !== -1)) {\n    zone.hasPendingMicrotasks = true;\n  } else {\n    zone.hasPendingMicrotasks = false;\n  }\n}\n\nfunction onEnter(zone: NgZonePrivate) {\n  zone._nesting++;\n  if (zone.isStable) {\n    zone.isStable = false;\n    zone.onUnstable.emit(null);\n  }\n}\n\nfunction onLeave(zone: NgZonePrivate) {\n  zone._nesting--;\n  checkStable(zone);\n}\n\n/**\n * Provides a noop implementation of `NgZone` which does nothing. This zone requires explicit calls\n * to framework to perform rendering.\n */\nexport class NoopNgZone implements NgZone {\n  readonly hasPendingMicrotasks: boolean = false;\n  readonly hasPendingMacrotasks: boolean = false;\n  readonly isStable: boolean = true;\n  readonly onUnstable: EventEmitter<any> = new EventEmitter();\n  readonly onMicrotaskEmpty: EventEmitter<any> = new EventEmitter();\n  readonly onStable: EventEmitter<any> = new EventEmitter();\n  readonly onError: EventEmitter<any> = new EventEmitter();\n\n  run(fn: (...args: any[]) => any, applyThis?: any, applyArgs?: any): any {\n    return fn.apply(applyThis, applyArgs);\n  }\n\n  runGuarded(fn: (...args: any[]) => any, applyThis?: any, applyArgs?: any): any {\n    return fn.apply(applyThis, applyArgs);\n  }\n\n  runOutsideAngular(fn: (...args: any[]) => any): any {\n    return fn();\n  }\n\n  runTask(fn: (...args: any[]) => any, applyThis?: any, applyArgs?: any, name?: string): any {\n    return fn.apply(applyThis, applyArgs);\n  }\n}\n"]}