diff --git a/packages/zone.js/lib/common/error-rewrite.ts b/packages/zone.js/lib/common/error-rewrite.ts index 8f51b571ce0..ccb5ffac258 100644 --- a/packages/zone.js/lib/common/error-rewrite.ts +++ b/packages/zone.js/lib/common/error-rewrite.ts @@ -10,19 +10,21 @@ * @suppress {globalThis,undefinedVars} */ -/** - * Extend the Error with additional fields for rewritten stack frames - */ -interface Error { +declare global { /** - * Stack trace where extra frames have been removed and zone names added. + * Extend the Error with additional fields for rewritten stack frames */ - zoneAwareStack?: string; + interface Error { + /** + * Stack trace where extra frames have been removed and zone names added. + */ + zoneAwareStack?: string; - /** - * Original stack trace with no modifications - */ - originalStack?: string; + /** + * Original stack trace with no modifications + */ + originalStack?: string; + } } Zone.__load_patch('Error', (global: any, Zone: ZoneType, api: _ZonePrivate) => { @@ -394,3 +396,5 @@ Zone.__load_patch('Error', (global: any, Zone: ZoneType, api: _ZonePrivate) => { (Error as any).stackTraceLimit = originalStackTraceLimit; }); + +export {}; diff --git a/packages/zone.js/lib/zone.api.extensions.ts b/packages/zone.js/lib/zone.api.extensions.ts index 2c47d706961..42a17b799b3 100644 --- a/packages/zone.js/lib/zone.api.extensions.ts +++ b/packages/zone.js/lib/zone.api.extensions.ts @@ -6,39 +6,43 @@ * found in the LICENSE file at https://angular.io/license */ -/** - * Additional `EventTarget` methods added by `Zone.js`. - * - * 1. removeAllListeners, remove all event listeners of the given event name. - * 2. eventListeners, get all event listeners of the given event name. - */ -interface EventTarget { +declare global { /** + * Additional `EventTarget` methods added by `Zone.js`. * - * Remove all event listeners by name for this event target. - * - * This method is optional because it may not be available if you use `noop zone` when - * bootstrapping Angular application or disable the `EventTarget` monkey patch by `zone.js`. - * - * If the `eventName` is provided, will remove event listeners of that name. - * If the `eventName` is not provided, will remove all event listeners associated with - * `EventTarget`. - * - * @param eventName the name of the event, such as `click`. This parameter is optional. + * 1. removeAllListeners, remove all event listeners of the given event name. + * 2. eventListeners, get all event listeners of the given event name. */ - removeAllListeners?(eventName?: string): void; - /** - * - * Retrieve all event listeners by name. - * - * This method is optional because it may not be available if you use `noop zone` when - * bootstrapping Angular application or disable the `EventTarget` monkey patch by `zone.js`. - * - * If the `eventName` is provided, will return an array of event handlers or event listener - * objects of the given event. - * If the `eventName` is not provided, will return all listeners. - * - * @param eventName the name of the event, such as click. This parameter is optional. - */ - eventListeners?(eventName?: string): EventListenerOrEventListenerObject[]; + interface EventTarget { + /** + * + * Remove all event listeners by name for this event target. + * + * This method is optional because it may not be available if you use `noop zone` when + * bootstrapping Angular application or disable the `EventTarget` monkey patch by `zone.js`. + * + * If the `eventName` is provided, will remove event listeners of that name. + * If the `eventName` is not provided, will remove all event listeners associated with + * `EventTarget`. + * + * @param eventName the name of the event, such as `click`. This parameter is optional. + */ + removeAllListeners?(eventName?: string): void; + /** + * + * Retrieve all event listeners by name. + * + * This method is optional because it may not be available if you use `noop zone` when + * bootstrapping Angular application or disable the `EventTarget` monkey patch by `zone.js`. + * + * If the `eventName` is provided, will return an array of event handlers or event listener + * objects of the given event. + * If the `eventName` is not provided, will return all listeners. + * + * @param eventName the name of the event, such as click. This parameter is optional. + */ + eventListeners?(eventName?: string): EventListenerOrEventListenerObject[]; + } } + +export {}; diff --git a/packages/zone.js/lib/zone.configurations.api.ts b/packages/zone.js/lib/zone.configurations.api.ts index 93dd691870c..0cb6bcc758c 100644 --- a/packages/zone.js/lib/zone.configurations.api.ts +++ b/packages/zone.js/lib/zone.configurations.api.ts @@ -6,785 +6,795 @@ * found in the LICENSE file at https://angular.io/license */ -/** - * Interface of `zone.js` configurations. - * - * You can define the following configurations on the `window/global` object before - * importing `zone.js` to change `zone.js` default behaviors. - */ -interface ZoneGlobalConfigurations { +declare global { /** - * Disable the monkey patch of the `Node.js` `EventEmitter` API. + * Interface of `zone.js` configurations. * - * By default, `zone.js` monkey patches the `Node.js` `EventEmitter` APIs to make asynchronous - * callbacks of those APIs in the same zone when scheduled. - * - * Consider the following example: - * - * ``` - * const EventEmitter = require('events'); - * class MyEmitter extends EventEmitter {} - * const myEmitter = new MyEmitter(); - * - * const zone = Zone.current.fork({name: 'myZone'}); - * zone.run(() => { - * myEmitter.on('event', () => { - * console.log('an event occurs in the zone', Zone.current.name); - * // the callback runs in the zone when it is scheduled, - * // so the output is 'an event occurs in the zone myZone'. - * }); - * }); - * myEmitter.emit('event'); - * ``` - * - * If you set `__Zone_disable_EventEmitter = true` before importing `zone.js`, - * `zone.js` does not monkey patch the `EventEmitter` APIs and the above code - * outputs 'an event occurred '. + * You can define the following configurations on the `window/global` object before + * importing `zone.js` to change `zone.js` default behaviors. */ - __Zone_disable_EventEmitter?: boolean; + interface ZoneGlobalConfigurations { + /** + * Disable the monkey patch of the `Node.js` `EventEmitter` API. + * + * By default, `zone.js` monkey patches the `Node.js` `EventEmitter` APIs to make asynchronous + * callbacks of those APIs in the same zone when scheduled. + * + * Consider the following example: + * + * ``` + * const EventEmitter = require('events'); + * class MyEmitter extends EventEmitter {} + * const myEmitter = new MyEmitter(); + * + * const zone = Zone.current.fork({name: 'myZone'}); + * zone.run(() => { + * myEmitter.on('event', () => { + * console.log('an event occurs in the zone', Zone.current.name); + * // the callback runs in the zone when it is scheduled, + * // so the output is 'an event occurs in the zone myZone'. + * }); + * }); + * myEmitter.emit('event'); + * ``` + * + * If you set `__Zone_disable_EventEmitter = true` before importing `zone.js`, + * `zone.js` does not monkey patch the `EventEmitter` APIs and the above code + * outputs 'an event occurred '. + */ + __Zone_disable_EventEmitter?: boolean; + + /** + * Disable the monkey patch of the `Node.js` `fs` API. + * + * By default, `zone.js` monkey patches `Node.js` `fs` APIs to make asynchronous callbacks of + * those APIs in the same zone when scheduled. + * + * Consider the following example: + * + * ``` + * const fs = require('fs'); + * + * const zone = Zone.current.fork({name: 'myZone'}); + * zone.run(() => { + * fs.stat('/tmp/world', (err, stats) => { + * console.log('fs.stats() callback is invoked in the zone', Zone.current.name); + * // since the callback of the `fs.stat()` runs in the same zone + * // when it is called, so the output is 'fs.stats() callback is invoked in the zone + * myZone'. + * }); + * }); + * ``` + * + * If you set `__Zone_disable_fs = true` before importing `zone.js`, + * `zone.js` does not monkey patch the `fs` API and the above code + * outputs 'get stats occurred '. + */ + __Zone_disable_fs?: boolean; + + /** + * Disable the monkey patch of the `Node.js` `timer` API. + * + * By default, `zone.js` monkey patches the `Node.js` `timer` APIs to make asynchronous + * callbacks of those APIs in the same zone when scheduled. + * + * Consider the following example: + * + * ``` + * const zone = Zone.current.fork({name: 'myZone'}); + * zone.run(() => { + * setTimeout(() => { + * console.log('setTimeout() callback is invoked in the zone', Zone.current.name); + * // since the callback of `setTimeout()` runs in the same zone + * // when it is scheduled, so the output is 'setTimeout() callback is invoked in the zone + * // myZone'. + * }); + * }); + * ``` + * + * If you set `__Zone_disable_timers = true` before importing `zone.js`, + * `zone.js` does not monkey patch the `timer` APIs and the above code + * outputs 'timeout '. + */ + __Zone_disable_node_timers?: boolean; + + /** + * Disable the monkey patch of the `Node.js` `process.nextTick()` API. + * + * By default, `zone.js` monkey patches the `Node.js` `process.nextTick()` API to make the + * callback in the same zone when calling `process.nextTick()`. + * + * Consider the following example: + * + * ``` + * const zone = Zone.current.fork({name: 'myZone'}); + * zone.run(() => { + * process.nextTick(() => { + * console.log('process.nextTick() callback is invoked in the zone', Zone.current.name); + * // since the callback of `process.nextTick()` runs in the same zone + * // when it is scheduled, so the output is 'process.nextTick() callback is invoked in the + * // zone myZone'. + * }); + * }); + * ``` + * + * If you set `__Zone_disable_nextTick = true` before importing `zone.js`, + * `zone.js` does not monkey patch the `process.nextTick()` API and the above code + * outputs 'nextTick '. + */ + __Zone_disable_nextTick?: boolean; + + /** + * Disable the monkey patch of the `Node.js` `crypto` API. + * + * By default, `zone.js` monkey patches the `Node.js` `crypto` APIs to make asynchronous + * callbacks of those APIs in the same zone when called. + * + * Consider the following example: + * + * ``` + * const crypto = require('crypto'); + * + * const zone = Zone.current.fork({name: 'myZone'}); + * zone.run(() => { + * crypto.randomBytes(() => { + * console.log('crypto.randomBytes() callback is invoked in the zone', Zone.current.name); + * // since the callback of `crypto.randomBytes()` runs in the same zone + * // when it is called, so the output is 'crypto.randomBytes() callback is invoked in the + * // zone myZone'. + * }); + * }); + * ``` + * + * If you set `__Zone_disable_crypto = true` before importing `zone.js`, + * `zone.js` does not monkey patch the `crypto` API and the above code + * outputs 'crypto '. + */ + __Zone_disable_crypto?: boolean; + + /** + * Disable the monkey patch of the `Object.defineProperty()` API. + * + * Note: This configuration is available only in the legacy bundle (dist/zone.js). This module + * is not available in the evergreen bundle (zone-evergreen.js). + * + * In the legacy browser, the default behavior of `zone.js` is to monkey patch + * `Object.defineProperty()` and `Object.create()` to try to ensure PropertyDescriptor + * parameter's configurable property to be true. This patch is only needed in some old mobile + * browsers. + * + * If you set `__Zone_disable_defineProperty = true` before importing `zone.js`, + * `zone.js` does not monkey patch the `Object.defineProperty()` API and does not + * modify desc.configurable to true. + * + */ + __Zone_disable_defineProperty?: boolean; + + /** + * Disable the monkey patch of the browser `registerElement()` API. + * + * NOTE: This configuration is only available in the legacy bundle (dist/zone.js), this + * module is not available in the evergreen bundle (zone-evergreen.js). + * + * In the legacy browser, the default behavior of `zone.js` is to monkey patch the + * `registerElement()` API to make asynchronous callbacks of the API in the same zone when + * `registerElement()` is called. + * + * Consider the following example: + * + * ``` + * const proto = Object.create(HTMLElement.prototype); + * proto.createdCallback = function() { + * console.log('createdCallback is invoked in the zone', Zone.current.name); + * }; + * proto.attachedCallback = function() { + * console.log('attachedCallback is invoked in the zone', Zone.current.name); + * }; + * proto.detachedCallback = function() { + * console.log('detachedCallback is invoked in the zone', Zone.current.name); + * }; + * proto.attributeChangedCallback = function() { + * console.log('attributeChangedCallback is invoked in the zone', Zone.current.name); + * }; + * + * const zone = Zone.current.fork({name: 'myZone'}); + * zone.run(() => { + * document.registerElement('x-elem', {prototype: proto}); + * }); + * ``` + * + * When these callbacks are invoked, those callbacks will be in the zone when + * `registerElement()` is called. + * + * If you set `__Zone_disable_registerElement = true` before importing `zone.js`, + * `zone.js` does not monkey patch `registerElement()` API and the above code + * outputs ''. + */ + __Zone_disable_registerElement?: boolean; + + /** + * Disable the monkey patch of the browser legacy `EventTarget` API. + * + * NOTE: This configuration is only available in the legacy bundle (dist/zone.js), this module + * is not available in the evergreen bundle (zone-evergreen.js). + * + * In some old browsers, the `EventTarget` is not available, so `zone.js` cannot directly monkey + * patch the `EventTarget`. Instead, `zone.js` patches all known HTML elements' prototypes (such + * as `HtmlDivElement`). The callback of the `addEventListener()` will be in the same zone when + * the `addEventListener()` is called. + * + * Consider the following example: + * + * ``` + * const zone = Zone.current.fork({name: 'myZone'}); + * zone.run(() => { + * div.addEventListener('click', () => { + * console.log('div click event listener is invoked in the zone', Zone.current.name); + * // the output is 'div click event listener is invoked in the zone myZone'. + * }); + * }); + * ``` + * + * If you set `__Zone_disable_EventTargetLegacy = true` before importing `zone.js` + * In some old browsers, where `EventTarget` is not available, if you set + * `__Zone_disable_EventTargetLegacy = true` before importing `zone.js`, `zone.js` does not + * monkey patch all HTML element APIs and the above code outputs 'clicked '. + */ + __Zone_disable_EventTargetLegacy?: boolean; + + /** + * Disable the monkey patch of the browser `timer` APIs. + * + * By default, `zone.js` monkey patches browser timer + * APIs (`setTimeout()`/`setInterval()`/`setImmediate()`) to make asynchronous callbacks of + * those APIs in the same zone when scheduled. + * + * Consider the following example: + * + * ``` + * const zone = Zone.current.fork({name: 'myZone'}); + * zone.run(() => { + * setTimeout(() => { + * console.log('setTimeout() callback is invoked in the zone', Zone.current.name); + * // since the callback of `setTimeout()` runs in the same zone + * // when it is scheduled, so the output is 'setTimeout() callback is invoked in the zone + * // myZone'. + * }); + * }); + * ``` + * + * If you set `__Zone_disable_timers = true` before importing `zone.js`, + * `zone.js` does not monkey patch `timer` API and the above code + * outputs 'timeout '. + * + */ + __Zone_disable_timers?: boolean; + + /** + * Disable the monkey patch of the browser `requestAnimationFrame()` API. + * + * By default, `zone.js` monkey patches the browser `requestAnimationFrame()` API + * to make the asynchronous callback of the `requestAnimationFrame()` in the same zone when + * scheduled. + * + * Consider the following example: + * + * ``` + * const zone = Zone.current.fork({name: 'myZone'}); + * zone.run(() => { + * requestAnimationFrame(() => { + * console.log('requestAnimationFrame() callback is invoked in the zone', + * Zone.current.name); + * // since the callback of `requestAnimationFrame()` will be in the same zone + * // when it is scheduled, so the output will be 'requestAnimationFrame() callback is + * invoked + * // in the zone myZone' + * }); + * }); + * ``` + * + * If you set `__Zone_disable_requestAnimationFrame = true` before importing `zone.js`, + * `zone.js` does not monkey patch the `requestAnimationFrame()` API and the above code + * outputs 'raf '. + */ + __Zone_disable_requestAnimationFrame?: boolean; + + /** + * + * Disable the monkey patching of the `queueMicrotask()` API. + * + * By default, `zone.js` monkey patches the `queueMicrotask()` API + * to ensure that `queueMicrotask()` callback is invoked in the same zone as zone used to invoke + * `queueMicrotask()`. And also the callback is running as `microTask` like + * `Promise.prototype.then()`. + * + * Consider the following example: + * + * ``` + * const zone = Zone.current.fork({name: 'myZone'}); + * zone.run(() => { + * queueMicrotask(() => { + * console.log('queueMicrotask() callback is invoked in the zone', Zone.current.name); + * // Since `queueMicrotask()` was invoked in `myZone`, same zone is restored + * // when 'queueMicrotask() callback is invoked, resulting in `myZone` being console + * logged. + * }); + * }); + * ``` + * + * If you set `__Zone_disable_queueMicrotask = true` before importing `zone.js`, + * `zone.js` does not monkey patch the `queueMicrotask()` API and the above code + * output will change to: 'queueMicrotask() callback is invoked in the zone '. + */ + __Zone_disable_queueMicrotask?: boolean; + + /** + * + * Disable the monkey patch of the browser blocking APIs(`alert()`/`prompt()`/`confirm()`). + */ + __Zone_disable_blocking?: boolean; + + /** + * Disable the monkey patch of the browser `EventTarget` APIs. + * + * By default, `zone.js` monkey patches EventTarget APIs. The callbacks of the + * `addEventListener()` run in the same zone when the `addEventListener()` is called. + * + * Consider the following example: + * + * ``` + * const zone = Zone.current.fork({name: 'myZone'}); + * zone.run(() => { + * div.addEventListener('click', () => { + * console.log('div event listener is invoked in the zone', Zone.current.name); + * // the output is 'div event listener is invoked in the zone myZone'. + * }); + * }); + * ``` + * + * If you set `__Zone_disable_EventTarget = true` before importing `zone.js`, + * `zone.js` does not monkey patch EventTarget API and the above code + * outputs 'clicked '. + * + */ + __Zone_disable_EventTarget?: boolean; + + /** + * Disable the monkey patch of the browser `FileReader` APIs. + */ + __Zone_disable_FileReader?: boolean; + + /** + * Disable the monkey patch of the browser `MutationObserver` APIs. + */ + __Zone_disable_MutationObserver?: boolean; + + /** + * Disable the monkey patch of the browser `IntersectionObserver` APIs. + */ + __Zone_disable_IntersectionObserver?: boolean; + + /** + * Disable the monkey patch of the browser onProperty APIs(such as onclick). + * + * By default, `zone.js` monkey patches onXXX properties (such as onclick). The callbacks of + * onXXX properties run in the same zone when the onXXX properties is set. + * + * Consider the following example: + * + * ``` + * const zone = Zone.current.fork({name: 'myZone'}); + * zone.run(() => { + * div.onclick = () => { + * console.log('div click event listener is invoked in the zone', Zone.current.name); + * // the output will be 'div click event listener is invoked in the zone myZone' + * } + * }); + * ``` + * + * If you set `__Zone_disable_on_property = true` before importing `zone.js`, + * `zone.js` does not monkey patch onXXX properties and the above code + * outputs 'clicked '. + * + */ + __Zone_disable_on_property?: boolean; + + /** + * Disable the monkey patch of the browser `customElements` APIs. + * + * By default, `zone.js` monkey patches `customElements` APIs to make callbacks run in the + * same zone when the `customElements.define()` is called. + * + * Consider the following example: + * + * ``` + * class TestCustomElement extends HTMLElement { + * constructor() { super(); } + * connectedCallback() {} + * disconnectedCallback() {} + * attributeChangedCallback(attrName, oldVal, newVal) {} + * adoptedCallback() {} + * } + * + * const zone = Zone.fork({name: 'myZone'}); + * zone.run(() => { + * customElements.define('x-elem', TestCustomElement); + * }); + * ``` + * + * All those callbacks defined in TestCustomElement runs in the zone when + * the `customElements.define()` is called. + * + * If you set `__Zone_disable_customElements = true` before importing `zone.js`, + * `zone.js` does not monkey patch `customElements` APIs and the above code + * runs inside zone. + */ + __Zone_disable_customElements?: boolean; + + /** + * Disable the monkey patch of the browser `XMLHttpRequest` APIs. + * + * By default, `zone.js` monkey patches `XMLHttpRequest` APIs to make XMLHttpRequest act + * as macroTask. + * + * Consider the following example: + * + * ``` + * const zone = Zone.current.fork({ + * name: 'myZone', + * onScheduleTask: (delegate, curr, target, task) => { + * console.log('task is scheduled', task.type, task.source, task.zone.name); + * return delegate.scheduleTask(target, task); + * } + * }) + * const xhr = new XMLHttpRequest(); + * zone.run(() => { + * xhr.onload = function() {}; + * xhr.open('get', '/', true); + * xhr.send(); + * }); + * ``` + * + * In this example, the instance of XMLHttpRequest runs in the zone and acts as a macroTask. The + * output is 'task is scheduled macroTask, XMLHttpRequest.send, zone'. + * + * If you set `__Zone_disable_XHR = true` before importing `zone.js`, + * `zone.js` does not monkey patch `XMLHttpRequest` APIs and the above onScheduleTask callback + * will not be called. + * + */ + __Zone_disable_XHR?: boolean; + + /** + * Disable the monkey patch of the browser geolocation APIs. + * + * By default, `zone.js` monkey patches geolocation APIs to make callbacks run in the same zone + * when those APIs are called. + * + * Consider the following examples: + * + * ``` + * const zone = Zone.current.fork({ + * name: 'myZone' + * }); + * + * zone.run(() => { + * navigator.geolocation.getCurrentPosition(pos => { + * console.log('navigator.getCurrentPosition() callback is invoked in the zone', + * Zone.current.name); + * // output is 'navigator.getCurrentPosition() callback is invoked in the zone myZone'. + * } + * }); + * ``` + * + * If set you `__Zone_disable_geolocation = true` before importing `zone.js`, + * `zone.js` does not monkey patch geolocation APIs and the above code + * outputs 'getCurrentPosition '. + * + */ + __Zone_disable_geolocation?: boolean; + + /** + * Disable the monkey patch of the browser `canvas` APIs. + * + * By default, `zone.js` monkey patches `canvas` APIs to make callbacks run in the same zone + * when those APIs are called. + * + * Consider the following example: + * + * ``` + * const zone = Zone.current.fork({ + * name: 'myZone' + * }); + * + * zone.run(() => { + * canvas.toBlob(blog => { + * console.log('canvas.toBlob() callback is invoked in the zone', Zone.current.name); + * // output is 'canvas.toBlob() callback is invoked in the zone myZone'. + * } + * }); + * ``` + * + * If you set `__Zone_disable_canvas = true` before importing `zone.js`, + * `zone.js` does not monkey patch `canvas` APIs and the above code + * outputs 'canvas.toBlob '. + */ + __Zone_disable_canvas?: boolean; + + /** + * Disable the `Promise` monkey patch. + * + * By default, `zone.js` monkey patches `Promise` APIs to make the `then()/catch()` callbacks in + * the same zone when those callbacks are called. + * + * Consider the following examples: + * + * ``` + * const zone = Zone.current.fork({name: 'myZone'}); + * + * const p = Promise.resolve(1); + * + * zone.run(() => { + * p.then(() => { + * console.log('then() callback is invoked in the zone', Zone.current.name); + * // output is 'then() callback is invoked in the zone myZone'. + * }); + * }); + * ``` + * + * If you set `__Zone_disable_ZoneAwarePromise = true` before importing `zone.js`, + * `zone.js` does not monkey patch `Promise` APIs and the above code + * outputs 'promise then callback '. + */ + __Zone_disable_ZoneAwarePromise?: boolean; + + /** + * Define event names that users don't want monkey patched by the `zone.js`. + * + * By default, `zone.js` monkey patches EventTarget.addEventListener(). The event listener + * callback runs in the same zone when the addEventListener() is called. + * + * Sometimes, you don't want all of the event names used in this patched version because it + * impacts performance. For example, you might want `scroll` or `mousemove` event listeners to + * run the native `addEventListener()` for better performance. + * + * Users can achieve this goal by defining `__zone_symbol__UNPATCHED_EVENTS = ['scroll', + * 'mousemove'];` before importing `zone.js`. + */ + __zone_symbol__UNPATCHED_EVENTS?: string[]; + + /** + * Define the event names of the passive listeners. + * + * To add passive event listeners, you can use `elem.addEventListener('scroll', listener, + * {passive: true});` or implement your own `EventManagerPlugin`. + * + * You can also define a global variable as follows: + * + * ``` + * __zone_symbol__PASSIVE_EVENTS = ['scroll']; + * ``` + * + * The preceding code makes all scroll event listeners passive. + */ + __zone_symbol__PASSIVE_EVENTS?: string[]; + + /** + * Disable wrapping uncaught promise rejection. + * + * By default, `zone.js` throws the original error occurs in the uncaught promise rejection. + * + * If you set `__zone_symbol__DISABLE_WRAPPING_UNCAUGHT_PROMISE_REJECTION = false;` before + * importing `zone.js`, `zone.js` will wrap the uncaught promise rejection in a new `Error` + * object which contains additional information such as a value of the rejection and a stack + * trace. + */ + __zone_symbol__DISABLE_WRAPPING_UNCAUGHT_PROMISE_REJECTION?: boolean; + } /** - * Disable the monkey patch of the `Node.js` `fs` API. + * Interface of `zone-testing.js` test configurations. * - * By default, `zone.js` monkey patches `Node.js` `fs` APIs to make asynchronous callbacks of - * those APIs in the same zone when scheduled. - * - * Consider the following example: - * - * ``` - * const fs = require('fs'); - * - * const zone = Zone.current.fork({name: 'myZone'}); - * zone.run(() => { - * fs.stat('/tmp/world', (err, stats) => { - * console.log('fs.stats() callback is invoked in the zone', Zone.current.name); - * // since the callback of the `fs.stat()` runs in the same zone - * // when it is called, so the output is 'fs.stats() callback is invoked in the zone myZone'. - * }); - * }); - * ``` - * - * If you set `__Zone_disable_fs = true` before importing `zone.js`, - * `zone.js` does not monkey patch the `fs` API and the above code - * outputs 'get stats occurred '. + * You can define the following configurations on the `window` or `global` object before + * importing `zone-testing.js` to change `zone-testing.js` default behaviors in the test runner. */ - __Zone_disable_fs?: boolean; + interface ZoneTestConfigurations { + /** + * Disable the Jasmine integration. + * + * In the `zone-testing.js` bundle, by default, `zone-testing.js` monkey patches Jasmine APIs + * to make Jasmine APIs run in specified zone. + * + * 1. Make the `describe()`/`xdescribe()`/`fdescribe()` methods run in the syncTestZone. + * 2. Make the `it()`/`xit()`/`fit()`/`beforeEach()`/`afterEach()`/`beforeAll()`/`afterAll()` + * methods run in the ProxyZone. + * + * With this patch, `async()`/`fakeAsync()` can work with the Jasmine runner. + * + * If you set `__Zone_disable_jasmine = true` before importing `zone-testing.js`, + * `zone-testing.js` does not monkey patch the jasmine APIs and the `async()`/`fakeAsync()` + * cannot work with the Jasmine runner any longer. + */ + __Zone_disable_jasmine?: boolean; + + /** + * Disable the Mocha integration. + * + * In the `zone-testing.js` bundle, by default, `zone-testing.js` monkey patches the Mocha APIs + * to make Mocha APIs run in the specified zone. + * + * 1. Make the `describe()`/`xdescribe()`/`fdescribe()` methods run in the syncTestZone. + * 2. Make the `it()`/`xit()`/`fit()`/`beforeEach()`/`afterEach()`/`beforeAll()`/`afterAll()` + * methods run in the ProxyZone. + * + * With this patch, `async()`/`fakeAsync()` can work with the Mocha runner. + * + * If you set `__Zone_disable_mocha = true` before importing `zone-testing.js`, + * `zone-testing.js` does not monkey patch the Mocha APIs and the `async()/`fakeAsync()` can not + * work with the Mocha runner any longer. + */ + __Zone_disable_mocha?: boolean; + + /** + * Disable the Jest integration. + * + * In the `zone-testing.js` bundle, by default, `zone-testing.js` monkey patches Jest APIs + * to make Jest APIs run in the specified zone. + * + * 1. Make the `describe()`/`xdescribe()`/`fdescribe()` methods run in the syncTestZone. + * 2. Make the `it()`/`xit()`/`fit()`/`beforeEach()`/`afterEach()`/`before()`/`after()` methods + * run in the ProxyZone. + * + * With this patch, `async()`/`fakeAsync()` can work with the Jest runner. + * + * If you set `__Zone_disable_jest = true` before importing `zone-testing.js`, + * `zone-testing.js` does not monkey patch the jest APIs and `async()`/`fakeAsync()` cannot + * work with the Jest runner any longer. + */ + __Zone_disable_jest?: boolean; + + /** + * Disable monkey patch the jasmine clock APIs. + * + * By default, `zone-testing.js` monkey patches the `jasmine.clock()` API, + * so the `jasmine.clock()` can work with the `fakeAsync()/tick()` API. + * + * Consider the following example: + * + * ``` + * describe('jasmine.clock integration', () => { + * beforeEach(() => { + * jasmine.clock().install(); + * }); + * afterEach(() => { + * jasmine.clock().uninstall(); + * }); + * it('fakeAsync test', fakeAsync(() => { + * setTimeout(spy, 100); + * expect(spy).not.toHaveBeenCalled(); + * jasmine.clock().tick(100); + * expect(spy).toHaveBeenCalled(); + * })); + * }); + * ``` + * + * In the `fakeAsync()` method, `jasmine.clock().tick()` works just like `tick()`. + * + * If you set `__zone_symbol__fakeAsyncDisablePatchingClock = true` before importing + * `zone-testing.js`,`zone-testing.js` does not monkey patch the `jasmine.clock()` APIs and the + * `jasmine.clock()` cannot work with `fakeAsync()` any longer. + */ + __zone_symbol__fakeAsyncDisablePatchingClock?: boolean; + + /** + * Enable auto running into `fakeAsync()` when installing the `jasmine.clock()`. + * + * By default, `zone-testing.js` does not automatically run into `fakeAsync()` + * if the `jasmine.clock().install()` is called. + * + * Consider the following example: + * + * ``` + * describe('jasmine.clock integration', () => { + * beforeEach(() => { + * jasmine.clock().install(); + * }); + * afterEach(() => { + * jasmine.clock().uninstall(); + * }); + * it('fakeAsync test', fakeAsync(() => { + * setTimeout(spy, 100); + * expect(spy).not.toHaveBeenCalled(); + * jasmine.clock().tick(100); + * expect(spy).toHaveBeenCalled(); + * })); + * }); + * ``` + * + * You must run `fakeAsync()` to make test cases in the `FakeAsyncTestZone`. + * + * If you set `__zone_symbol__fakeAsyncAutoFakeAsyncWhenClockPatched = true` before importing + * `zone-testing.js`, `zone-testing.js` can run test case automatically in the + * `FakeAsyncTestZone` without calling the `fakeAsync()`. + * + * Consider the following example: + * + * ``` + * describe('jasmine.clock integration', () => { + * beforeEach(() => { + * jasmine.clock().install(); + * }); + * afterEach(() => { + * jasmine.clock().uninstall(); + * }); + * it('fakeAsync test', () => { // here we don't need to call fakeAsync + * setTimeout(spy, 100); + * expect(spy).not.toHaveBeenCalled(); + * jasmine.clock().tick(100); + * expect(spy).toHaveBeenCalled(); + * }); + * }); + * ``` + * + */ + __zone_symbol__fakeAsyncAutoFakeAsyncWhenClockPatched?: boolean; + + /** + * Enable waiting for the unresolved promise in the `async()` test. + * + * In the `async()` test, `AsyncTestZone` waits for all the asynchronous tasks to finish. By + * default, if some promises remain unresolved, `AsyncTestZone` does not wait and reports that + * it received an unexpected result. + * + * Consider the following example: + * + * ``` + * describe('wait never resolved promise', () => { + * it('async with never resolved promise test', async(() => { + * const p = new Promise(() => {}); + * p.then(() => { + * // do some expectation. + * }); + * })) + * }); + * ``` + * + * By default, this case passes, because the callback of `p.then()` is never called. Because `p` + * is an unresolved promise, there is no pending asynchronous task, which means the `async()` + * method does not wait. + * + * If you set `__zone_symbol__supportWaitUnResolvedChainedPromise = true`, the above case + * times out, because `async()` will wait for the unresolved promise. + */ + __zone_symbol__supportWaitUnResolvedChainedPromise?: boolean; + } /** - * Disable the monkey patch of the `Node.js` `timer` API. + * The interface of the `zone.js` runtime configurations. * - * By default, `zone.js` monkey patches the `Node.js` `timer` APIs to make asynchronous - * callbacks of those APIs in the same zone when scheduled. + * These configurations can be defined on the `Zone` object after + * importing zone.js to change behaviors. The differences between + * the `ZoneRuntimeConfigurations` and the `ZoneGlobalConfigurations` are, * - * Consider the following example: + * 1. `ZoneGlobalConfigurations` must be defined on the `global/window` object before importing + * `zone.js`. The value of the configuration cannot be changed at runtime. * - * ``` - * const zone = Zone.current.fork({name: 'myZone'}); - * zone.run(() => { - * setTimeout(() => { - * console.log('setTimeout() callback is invoked in the zone', Zone.current.name); - * // since the callback of `setTimeout()` runs in the same zone - * // when it is scheduled, so the output is 'setTimeout() callback is invoked in the zone - * // myZone'. - * }); - * }); - * ``` - * - * If you set `__Zone_disable_timers = true` before importing `zone.js`, - * `zone.js` does not monkey patch the `timer` APIs and the above code - * outputs 'timeout '. - */ - __Zone_disable_node_timers?: boolean; - - /** - * Disable the monkey patch of the `Node.js` `process.nextTick()` API. - * - * By default, `zone.js` monkey patches the `Node.js` `process.nextTick()` API to make the - * callback in the same zone when calling `process.nextTick()`. - * - * Consider the following example: - * - * ``` - * const zone = Zone.current.fork({name: 'myZone'}); - * zone.run(() => { - * process.nextTick(() => { - * console.log('process.nextTick() callback is invoked in the zone', Zone.current.name); - * // since the callback of `process.nextTick()` runs in the same zone - * // when it is scheduled, so the output is 'process.nextTick() callback is invoked in the - * // zone myZone'. - * }); - * }); - * ``` - * - * If you set `__Zone_disable_nextTick = true` before importing `zone.js`, - * `zone.js` does not monkey patch the `process.nextTick()` API and the above code - * outputs 'nextTick '. - */ - __Zone_disable_nextTick?: boolean; - - /** - * Disable the monkey patch of the `Node.js` `crypto` API. - * - * By default, `zone.js` monkey patches the `Node.js` `crypto` APIs to make asynchronous callbacks - * of those APIs in the same zone when called. - * - * Consider the following example: - * - * ``` - * const crypto = require('crypto'); - * - * const zone = Zone.current.fork({name: 'myZone'}); - * zone.run(() => { - * crypto.randomBytes(() => { - * console.log('crypto.randomBytes() callback is invoked in the zone', Zone.current.name); - * // since the callback of `crypto.randomBytes()` runs in the same zone - * // when it is called, so the output is 'crypto.randomBytes() callback is invoked in the - * // zone myZone'. - * }); - * }); - * ``` - * - * If you set `__Zone_disable_crypto = true` before importing `zone.js`, - * `zone.js` does not monkey patch the `crypto` API and the above code - * outputs 'crypto '. - */ - __Zone_disable_crypto?: boolean; - - /** - * Disable the monkey patch of the `Object.defineProperty()` API. - * - * Note: This configuration is available only in the legacy bundle (dist/zone.js). This module is - * not available in the evergreen bundle (zone-evergreen.js). - * - * In the legacy browser, the default behavior of `zone.js` is to monkey patch - * `Object.defineProperty()` and `Object.create()` to try to ensure PropertyDescriptor parameter's - * configurable property to be true. This patch is only needed in some old mobile browsers. - * - * If you set `__Zone_disable_defineProperty = true` before importing `zone.js`, - * `zone.js` does not monkey patch the `Object.defineProperty()` API and does not - * modify desc.configurable to true. + * 2. `ZoneRuntimeConfigurations` must be defined on the `Zone` object after importing `zone.js`. + * You can change the value of this configuration at runtime. * */ - __Zone_disable_defineProperty?: boolean; - - /** - * Disable the monkey patch of the browser `registerElement()` API. - * - * NOTE: This configuration is only available in the legacy bundle (dist/zone.js), this - * module is not available in the evergreen bundle (zone-evergreen.js). - * - * In the legacy browser, the default behavior of `zone.js` is to monkey patch the - * `registerElement()` API to make asynchronous callbacks of the API in the same zone when - * `registerElement()` is called. - * - * Consider the following example: - * - * ``` - * const proto = Object.create(HTMLElement.prototype); - * proto.createdCallback = function() { - * console.log('createdCallback is invoked in the zone', Zone.current.name); - * }; - * proto.attachedCallback = function() { - * console.log('attachedCallback is invoked in the zone', Zone.current.name); - * }; - * proto.detachedCallback = function() { - * console.log('detachedCallback is invoked in the zone', Zone.current.name); - * }; - * proto.attributeChangedCallback = function() { - * console.log('attributeChangedCallback is invoked in the zone', Zone.current.name); - * }; - * - * const zone = Zone.current.fork({name: 'myZone'}); - * zone.run(() => { - * document.registerElement('x-elem', {prototype: proto}); - * }); - * ``` - * - * When these callbacks are invoked, those callbacks will be in the zone when - * `registerElement()` is called. - * - * If you set `__Zone_disable_registerElement = true` before importing `zone.js`, - * `zone.js` does not monkey patch `registerElement()` API and the above code - * outputs ''. - */ - __Zone_disable_registerElement?: boolean; - - /** - * Disable the monkey patch of the browser legacy `EventTarget` API. - * - * NOTE: This configuration is only available in the legacy bundle (dist/zone.js), this module - * is not available in the evergreen bundle (zone-evergreen.js). - * - * In some old browsers, the `EventTarget` is not available, so `zone.js` cannot directly monkey - * patch the `EventTarget`. Instead, `zone.js` patches all known HTML elements' prototypes (such - * as `HtmlDivElement`). The callback of the `addEventListener()` will be in the same zone when - * the `addEventListener()` is called. - * - * Consider the following example: - * - * ``` - * const zone = Zone.current.fork({name: 'myZone'}); - * zone.run(() => { - * div.addEventListener('click', () => { - * console.log('div click event listener is invoked in the zone', Zone.current.name); - * // the output is 'div click event listener is invoked in the zone myZone'. - * }); - * }); - * ``` - * - * If you set `__Zone_disable_EventTargetLegacy = true` before importing `zone.js` - * In some old browsers, where `EventTarget` is not available, if you set - * `__Zone_disable_EventTargetLegacy = true` before importing `zone.js`, `zone.js` does not monkey - * patch all HTML element APIs and the above code outputs 'clicked '. - */ - __Zone_disable_EventTargetLegacy?: boolean; - - /** - * Disable the monkey patch of the browser `timer` APIs. - * - * By default, `zone.js` monkey patches browser timer - * APIs (`setTimeout()`/`setInterval()`/`setImmediate()`) to make asynchronous callbacks of those - * APIs in the same zone when scheduled. - * - * Consider the following example: - * - * ``` - * const zone = Zone.current.fork({name: 'myZone'}); - * zone.run(() => { - * setTimeout(() => { - * console.log('setTimeout() callback is invoked in the zone', Zone.current.name); - * // since the callback of `setTimeout()` runs in the same zone - * // when it is scheduled, so the output is 'setTimeout() callback is invoked in the zone - * // myZone'. - * }); - * }); - * ``` - * - * If you set `__Zone_disable_timers = true` before importing `zone.js`, - * `zone.js` does not monkey patch `timer` API and the above code - * outputs 'timeout '. - * - */ - __Zone_disable_timers?: boolean; - - /** - * Disable the monkey patch of the browser `requestAnimationFrame()` API. - * - * By default, `zone.js` monkey patches the browser `requestAnimationFrame()` API - * to make the asynchronous callback of the `requestAnimationFrame()` in the same zone when - * scheduled. - * - * Consider the following example: - * - * ``` - * const zone = Zone.current.fork({name: 'myZone'}); - * zone.run(() => { - * requestAnimationFrame(() => { - * console.log('requestAnimationFrame() callback is invoked in the zone', Zone.current.name); - * // since the callback of `requestAnimationFrame()` will be in the same zone - * // when it is scheduled, so the output will be 'requestAnimationFrame() callback is invoked - * // in the zone myZone' - * }); - * }); - * ``` - * - * If you set `__Zone_disable_requestAnimationFrame = true` before importing `zone.js`, - * `zone.js` does not monkey patch the `requestAnimationFrame()` API and the above code - * outputs 'raf '. - */ - __Zone_disable_requestAnimationFrame?: boolean; - - /** - * - * Disable the monkey patching of the `queueMicrotask()` API. - * - * By default, `zone.js` monkey patches the `queueMicrotask()` API - * to ensure that `queueMicrotask()` callback is invoked in the same zone as zone used to invoke - * `queueMicrotask()`. And also the callback is running as `microTask` like - * `Promise.prototype.then()`. - * - * Consider the following example: - * - * ``` - * const zone = Zone.current.fork({name: 'myZone'}); - * zone.run(() => { - * queueMicrotask(() => { - * console.log('queueMicrotask() callback is invoked in the zone', Zone.current.name); - * // Since `queueMicrotask()` was invoked in `myZone`, same zone is restored - * // when 'queueMicrotask() callback is invoked, resulting in `myZone` being console logged. - * }); - * }); - * ``` - * - * If you set `__Zone_disable_queueMicrotask = true` before importing `zone.js`, - * `zone.js` does not monkey patch the `queueMicrotask()` API and the above code - * output will change to: 'queueMicrotask() callback is invoked in the zone '. - */ - __Zone_disable_queueMicrotask?: boolean; - - /** - * - * Disable the monkey patch of the browser blocking APIs(`alert()`/`prompt()`/`confirm()`). - */ - __Zone_disable_blocking?: boolean; - - /** - * Disable the monkey patch of the browser `EventTarget` APIs. - * - * By default, `zone.js` monkey patches EventTarget APIs. The callbacks of the - * `addEventListener()` run in the same zone when the `addEventListener()` is called. - * - * Consider the following example: - * - * ``` - * const zone = Zone.current.fork({name: 'myZone'}); - * zone.run(() => { - * div.addEventListener('click', () => { - * console.log('div event listener is invoked in the zone', Zone.current.name); - * // the output is 'div event listener is invoked in the zone myZone'. - * }); - * }); - * ``` - * - * If you set `__Zone_disable_EventTarget = true` before importing `zone.js`, - * `zone.js` does not monkey patch EventTarget API and the above code - * outputs 'clicked '. - * - */ - __Zone_disable_EventTarget?: boolean; - - /** - * Disable the monkey patch of the browser `FileReader` APIs. - */ - __Zone_disable_FileReader?: boolean; - - /** - * Disable the monkey patch of the browser `MutationObserver` APIs. - */ - __Zone_disable_MutationObserver?: boolean; - - /** - * Disable the monkey patch of the browser `IntersectionObserver` APIs. - */ - __Zone_disable_IntersectionObserver?: boolean; - - /** - * Disable the monkey patch of the browser onProperty APIs(such as onclick). - * - * By default, `zone.js` monkey patches onXXX properties (such as onclick). The callbacks of onXXX - * properties run in the same zone when the onXXX properties is set. - * - * Consider the following example: - * - * ``` - * const zone = Zone.current.fork({name: 'myZone'}); - * zone.run(() => { - * div.onclick = () => { - * console.log('div click event listener is invoked in the zone', Zone.current.name); - * // the output will be 'div click event listener is invoked in the zone myZone' - * } - * }); - * ``` - * - * If you set `__Zone_disable_on_property = true` before importing `zone.js`, - * `zone.js` does not monkey patch onXXX properties and the above code - * outputs 'clicked '. - * - */ - __Zone_disable_on_property?: boolean; - - /** - * Disable the monkey patch of the browser `customElements` APIs. - * - * By default, `zone.js` monkey patches `customElements` APIs to make callbacks run in the - * same zone when the `customElements.define()` is called. - * - * Consider the following example: - * - * ``` - * class TestCustomElement extends HTMLElement { - * constructor() { super(); } - * connectedCallback() {} - * disconnectedCallback() {} - * attributeChangedCallback(attrName, oldVal, newVal) {} - * adoptedCallback() {} - * } - * - * const zone = Zone.fork({name: 'myZone'}); - * zone.run(() => { - * customElements.define('x-elem', TestCustomElement); - * }); - * ``` - * - * All those callbacks defined in TestCustomElement runs in the zone when - * the `customElements.define()` is called. - * - * If you set `__Zone_disable_customElements = true` before importing `zone.js`, - * `zone.js` does not monkey patch `customElements` APIs and the above code - * runs inside zone. - */ - __Zone_disable_customElements?: boolean; - - /** - * Disable the monkey patch of the browser `XMLHttpRequest` APIs. - * - * By default, `zone.js` monkey patches `XMLHttpRequest` APIs to make XMLHttpRequest act - * as macroTask. - * - * Consider the following example: - * - * ``` - * const zone = Zone.current.fork({ - * name: 'myZone', - * onScheduleTask: (delegate, curr, target, task) => { - * console.log('task is scheduled', task.type, task.source, task.zone.name); - * return delegate.scheduleTask(target, task); - * } - * }) - * const xhr = new XMLHttpRequest(); - * zone.run(() => { - * xhr.onload = function() {}; - * xhr.open('get', '/', true); - * xhr.send(); - * }); - * ``` - * - * In this example, the instance of XMLHttpRequest runs in the zone and acts as a macroTask. The - * output is 'task is scheduled macroTask, XMLHttpRequest.send, zone'. - * - * If you set `__Zone_disable_XHR = true` before importing `zone.js`, - * `zone.js` does not monkey patch `XMLHttpRequest` APIs and the above onScheduleTask callback - * will not be called. - * - */ - __Zone_disable_XHR?: boolean; - - /** - * Disable the monkey patch of the browser geolocation APIs. - * - * By default, `zone.js` monkey patches geolocation APIs to make callbacks run in the same zone - * when those APIs are called. - * - * Consider the following examples: - * - * ``` - * const zone = Zone.current.fork({ - * name: 'myZone' - * }); - * - * zone.run(() => { - * navigator.geolocation.getCurrentPosition(pos => { - * console.log('navigator.getCurrentPosition() callback is invoked in the zone', - * Zone.current.name); - * // output is 'navigator.getCurrentPosition() callback is invoked in the zone myZone'. - * } - * }); - * ``` - * - * If set you `__Zone_disable_geolocation = true` before importing `zone.js`, - * `zone.js` does not monkey patch geolocation APIs and the above code - * outputs 'getCurrentPosition '. - * - */ - __Zone_disable_geolocation?: boolean; - - /** - * Disable the monkey patch of the browser `canvas` APIs. - * - * By default, `zone.js` monkey patches `canvas` APIs to make callbacks run in the same zone when - * those APIs are called. - * - * Consider the following example: - * - * ``` - * const zone = Zone.current.fork({ - * name: 'myZone' - * }); - * - * zone.run(() => { - * canvas.toBlob(blog => { - * console.log('canvas.toBlob() callback is invoked in the zone', Zone.current.name); - * // output is 'canvas.toBlob() callback is invoked in the zone myZone'. - * } - * }); - * ``` - * - * If you set `__Zone_disable_canvas = true` before importing `zone.js`, - * `zone.js` does not monkey patch `canvas` APIs and the above code - * outputs 'canvas.toBlob '. - */ - __Zone_disable_canvas?: boolean; - - /** - * Disable the `Promise` monkey patch. - * - * By default, `zone.js` monkey patches `Promise` APIs to make the `then()/catch()` callbacks in - * the same zone when those callbacks are called. - * - * Consider the following examples: - * - * ``` - * const zone = Zone.current.fork({name: 'myZone'}); - * - * const p = Promise.resolve(1); - * - * zone.run(() => { - * p.then(() => { - * console.log('then() callback is invoked in the zone', Zone.current.name); - * // output is 'then() callback is invoked in the zone myZone'. - * }); - * }); - * ``` - * - * If you set `__Zone_disable_ZoneAwarePromise = true` before importing `zone.js`, - * `zone.js` does not monkey patch `Promise` APIs and the above code - * outputs 'promise then callback '. - */ - __Zone_disable_ZoneAwarePromise?: boolean; - - /** - * Define event names that users don't want monkey patched by the `zone.js`. - * - * By default, `zone.js` monkey patches EventTarget.addEventListener(). The event listener - * callback runs in the same zone when the addEventListener() is called. - * - * Sometimes, you don't want all of the event names used in this patched version because it - * impacts performance. For example, you might want `scroll` or `mousemove` event listeners to run - * the native `addEventListener()` for better performance. - * - * Users can achieve this goal by defining `__zone_symbol__UNPATCHED_EVENTS = ['scroll', - * 'mousemove'];` before importing `zone.js`. - */ - __zone_symbol__UNPATCHED_EVENTS?: string[]; - - /** - * Define the event names of the passive listeners. - * - * To add passive event listeners, you can use `elem.addEventListener('scroll', listener, - * {passive: true});` or implement your own `EventManagerPlugin`. - * - * You can also define a global variable as follows: - * - * ``` - * __zone_symbol__PASSIVE_EVENTS = ['scroll']; - * ``` - * - * The preceding code makes all scroll event listeners passive. - */ - __zone_symbol__PASSIVE_EVENTS?: string[]; - - /** - * Disable wrapping uncaught promise rejection. - * - * By default, `zone.js` throws the original error occurs in the uncaught promise rejection. - * - * If you set `__zone_symbol__DISABLE_WRAPPING_UNCAUGHT_PROMISE_REJECTION = false;` before - * importing `zone.js`, `zone.js` will wrap the uncaught promise rejection in a new `Error` object - * which contains additional information such as a value of the rejection and a stack trace. - */ - __zone_symbol__DISABLE_WRAPPING_UNCAUGHT_PROMISE_REJECTION?: boolean; + interface ZoneRuntimeConfigurations { + /** + * Ignore outputting errors to the console when uncaught Promise errors occur. + * + * By default, if an uncaught Promise error occurs, `zone.js` outputs the + * error to the console by calling `console.error()`. + * + * If you set `__zone_symbol__ignoreConsoleErrorUncaughtError = true`, `zone.js` does not output + * the uncaught error to `console.error()`. + */ + __zone_symbol__ignoreConsoleErrorUncaughtError?: boolean; + } } -/** - * Interface of `zone-testing.js` test configurations. - * - * You can define the following configurations on the `window` or `global` object before - * importing `zone-testing.js` to change `zone-testing.js` default behaviors in the test runner. - */ -interface ZoneTestConfigurations { - /** - * Disable the Jasmine integration. - * - * In the `zone-testing.js` bundle, by default, `zone-testing.js` monkey patches Jasmine APIs - * to make Jasmine APIs run in specified zone. - * - * 1. Make the `describe()`/`xdescribe()`/`fdescribe()` methods run in the syncTestZone. - * 2. Make the `it()`/`xit()`/`fit()`/`beforeEach()`/`afterEach()`/`beforeAll()`/`afterAll()` - * methods run in the ProxyZone. - * - * With this patch, `async()`/`fakeAsync()` can work with the Jasmine runner. - * - * If you set `__Zone_disable_jasmine = true` before importing `zone-testing.js`, - * `zone-testing.js` does not monkey patch the jasmine APIs and the `async()`/`fakeAsync()` cannot - * work with the Jasmine runner any longer. - */ - __Zone_disable_jasmine?: boolean; - - /** - * Disable the Mocha integration. - * - * In the `zone-testing.js` bundle, by default, `zone-testing.js` monkey patches the Mocha APIs - * to make Mocha APIs run in the specified zone. - * - * 1. Make the `describe()`/`xdescribe()`/`fdescribe()` methods run in the syncTestZone. - * 2. Make the `it()`/`xit()`/`fit()`/`beforeEach()`/`afterEach()`/`beforeAll()`/`afterAll()` - * methods run in the ProxyZone. - * - * With this patch, `async()`/`fakeAsync()` can work with the Mocha runner. - * - * If you set `__Zone_disable_mocha = true` before importing `zone-testing.js`, - * `zone-testing.js` does not monkey patch the Mocha APIs and the `async()/`fakeAsync()` can not - * work with the Mocha runner any longer. - */ - __Zone_disable_mocha?: boolean; - - /** - * Disable the Jest integration. - * - * In the `zone-testing.js` bundle, by default, `zone-testing.js` monkey patches Jest APIs - * to make Jest APIs run in the specified zone. - * - * 1. Make the `describe()`/`xdescribe()`/`fdescribe()` methods run in the syncTestZone. - * 2. Make the `it()`/`xit()`/`fit()`/`beforeEach()`/`afterEach()`/`before()`/`after()` methods - * run in the ProxyZone. - * - * With this patch, `async()`/`fakeAsync()` can work with the Jest runner. - * - * If you set `__Zone_disable_jest = true` before importing `zone-testing.js`, - * `zone-testing.js` does not monkey patch the jest APIs and `async()`/`fakeAsync()` cannot - * work with the Jest runner any longer. - */ - __Zone_disable_jest?: boolean; - - /** - * Disable monkey patch the jasmine clock APIs. - * - * By default, `zone-testing.js` monkey patches the `jasmine.clock()` API, - * so the `jasmine.clock()` can work with the `fakeAsync()/tick()` API. - * - * Consider the following example: - * - * ``` - * describe('jasmine.clock integration', () => { - * beforeEach(() => { - * jasmine.clock().install(); - * }); - * afterEach(() => { - * jasmine.clock().uninstall(); - * }); - * it('fakeAsync test', fakeAsync(() => { - * setTimeout(spy, 100); - * expect(spy).not.toHaveBeenCalled(); - * jasmine.clock().tick(100); - * expect(spy).toHaveBeenCalled(); - * })); - * }); - * ``` - * - * In the `fakeAsync()` method, `jasmine.clock().tick()` works just like `tick()`. - * - * If you set `__zone_symbol__fakeAsyncDisablePatchingClock = true` before importing - * `zone-testing.js`,`zone-testing.js` does not monkey patch the `jasmine.clock()` APIs and the - * `jasmine.clock()` cannot work with `fakeAsync()` any longer. - */ - __zone_symbol__fakeAsyncDisablePatchingClock?: boolean; - - /** - * Enable auto running into `fakeAsync()` when installing the `jasmine.clock()`. - * - * By default, `zone-testing.js` does not automatically run into `fakeAsync()` - * if the `jasmine.clock().install()` is called. - * - * Consider the following example: - * - * ``` - * describe('jasmine.clock integration', () => { - * beforeEach(() => { - * jasmine.clock().install(); - * }); - * afterEach(() => { - * jasmine.clock().uninstall(); - * }); - * it('fakeAsync test', fakeAsync(() => { - * setTimeout(spy, 100); - * expect(spy).not.toHaveBeenCalled(); - * jasmine.clock().tick(100); - * expect(spy).toHaveBeenCalled(); - * })); - * }); - * ``` - * - * You must run `fakeAsync()` to make test cases in the `FakeAsyncTestZone`. - * - * If you set `__zone_symbol__fakeAsyncAutoFakeAsyncWhenClockPatched = true` before importing - * `zone-testing.js`, `zone-testing.js` can run test case automatically in the - * `FakeAsyncTestZone` without calling the `fakeAsync()`. - * - * Consider the following example: - * - * ``` - * describe('jasmine.clock integration', () => { - * beforeEach(() => { - * jasmine.clock().install(); - * }); - * afterEach(() => { - * jasmine.clock().uninstall(); - * }); - * it('fakeAsync test', () => { // here we don't need to call fakeAsync - * setTimeout(spy, 100); - * expect(spy).not.toHaveBeenCalled(); - * jasmine.clock().tick(100); - * expect(spy).toHaveBeenCalled(); - * }); - * }); - * ``` - * - */ - __zone_symbol__fakeAsyncAutoFakeAsyncWhenClockPatched?: boolean; - - /** - * Enable waiting for the unresolved promise in the `async()` test. - * - * In the `async()` test, `AsyncTestZone` waits for all the asynchronous tasks to finish. By - * default, if some promises remain unresolved, `AsyncTestZone` does not wait and reports that it - * received an unexpected result. - * - * Consider the following example: - * - * ``` - * describe('wait never resolved promise', () => { - * it('async with never resolved promise test', async(() => { - * const p = new Promise(() => {}); - * p.then(() => { - * // do some expectation. - * }); - * })) - * }); - * ``` - * - * By default, this case passes, because the callback of `p.then()` is never called. Because `p` - * is an unresolved promise, there is no pending asynchronous task, which means the `async()` - * method does not wait. - * - * If you set `__zone_symbol__supportWaitUnResolvedChainedPromise = true`, the above case - * times out, because `async()` will wait for the unresolved promise. - */ - __zone_symbol__supportWaitUnResolvedChainedPromise?: boolean; -} - -/** - * The interface of the `zone.js` runtime configurations. - * - * These configurations can be defined on the `Zone` object after - * importing zone.js to change behaviors. The differences between - * the `ZoneRuntimeConfigurations` and the `ZoneGlobalConfigurations` are, - * - * 1. `ZoneGlobalConfigurations` must be defined on the `global/window` object before importing - * `zone.js`. The value of the configuration cannot be changed at runtime. - * - * 2. `ZoneRuntimeConfigurations` must be defined on the `Zone` object after importing `zone.js`. - * You can change the value of this configuration at runtime. - * - */ -interface ZoneRuntimeConfigurations { - /** - * Ignore outputting errors to the console when uncaught Promise errors occur. - * - * By default, if an uncaught Promise error occurs, `zone.js` outputs the - * error to the console by calling `console.error()`. - * - * If you set `__zone_symbol__ignoreConsoleErrorUncaughtError = true`, `zone.js` does not output - * the uncaught error to `console.error()`. - */ - __zone_symbol__ignoreConsoleErrorUncaughtError?: boolean; -} +export {}; diff --git a/packages/zone.js/lib/zone.ts b/packages/zone.js/lib/zone.ts index 22df12f5afc..fb4fab53569 100644 --- a/packages/zone.js/lib/zone.ts +++ b/packages/zone.js/lib/zone.ts @@ -12,1437 +12,1446 @@ * @suppress {undefinedVars} */ -/** - * Zone is a mechanism for intercepting and keeping track of asynchronous work. - * - * A Zone is a global object which is configured with rules about how to intercept and keep track - * of the asynchronous callbacks. Zone has these responsibilities: - * - * 1. Intercept asynchronous task scheduling - * 2. Wrap callbacks for error-handling and zone tracking across async operations. - * 3. Provide a way to attach data to zones - * 4. Provide a context specific last frame error handling - * 5. (Intercept blocking methods) - * - * A zone by itself does not do anything, instead it relies on some other code to route existing - * platform API through it. (The zone library ships with code which monkey patches all of the - * browsers's asynchronous API and redirects them through the zone for interception.) - * - * In its simplest form a zone allows one to intercept the scheduling and calling of asynchronous - * operations, and execute additional code before as well as after the asynchronous task. The rules - * of interception are configured using [ZoneConfig]. There can be many different zone instances in - * a system, but only one zone is active at any given time which can be retrieved using - * [Zone#current]. - * - * - * - * ## Callback Wrapping - * - * An important aspect of the zones is that they should persist across asynchronous operations. To - * achieve this, when a future work is scheduled through async API, it is necessary to capture, and - * subsequently restore the current zone. For example if a code is running in zone `b` and it - * invokes `setTimeout` to scheduleTask work later, the `setTimeout` method needs to 1) capture the - * current zone and 2) wrap the `wrapCallback` in code which will restore the current zone `b` once - * the wrapCallback executes. In this way the rules which govern the current code are preserved in - * all future asynchronous tasks. There could be a different zone `c` which has different rules and - * is associated with different asynchronous tasks. As these tasks are processed, each asynchronous - * wrapCallback correctly restores the correct zone, as well as preserves the zone for future - * asynchronous callbacks. - * - * Example: Suppose a browser page consist of application code as well as third-party - * advertisement code. (These two code bases are independent, developed by different mutually - * unaware developers.) The application code may be interested in doing global error handling and - * so it configures the `app` zone to send all of the errors to the server for analysis, and then - * executes the application in the `app` zone. The advertising code is interested in the same - * error processing but it needs to send the errors to a different third-party. So it creates the - * `ads` zone with a different error handler. Now both advertising as well as application code - * create many asynchronous operations, but the [Zone] will ensure that all of the asynchronous - * operations created from the application code will execute in `app` zone with its error - * handler and all of the advertisement code will execute in the `ads` zone with its error handler. - * This will not only work for the async operations created directly, but also for all subsequent - * asynchronous operations. - * - * If you think of chain of asynchronous operations as a thread of execution (bit of a stretch) - * then [Zone#current] will act as a thread local variable. - * - * - * - * ## Asynchronous operation scheduling - * - * In addition to wrapping the callbacks to restore the zone, all operations which cause a - * scheduling of work for later are routed through the current zone which is allowed to intercept - * them by adding work before or after the wrapCallback as well as using different means of - * achieving the request. (Useful for unit testing, or tracking of requests). In some instances - * such as `setTimeout` the wrapping of the wrapCallback and scheduling is done in the same - * wrapCallback, but there are other examples such as `Promises` where the `then` wrapCallback is - * wrapped, but the execution of `then` is triggered by `Promise` scheduling `resolve` work. - * - * Fundamentally there are three kinds of tasks which can be scheduled: - * - * 1. [MicroTask] used for doing work right after the current task. This is non-cancelable which is - * guaranteed to run exactly once and immediately. - * 2. [MacroTask] used for doing work later. Such as `setTimeout`. This is typically cancelable - * which is guaranteed to execute at least once after some well understood delay. - * 3. [EventTask] used for listening on some future event. This may execute zero or more times, with - * an unknown delay. - * - * Each asynchronous API is modeled and routed through one of these APIs. - * - * - * ### [MicroTask] - * - * [MicroTask]s represent work which will be done in current VM turn as soon as possible, before VM - * yielding. - * - * - * ### [MacroTask] - * - * [MacroTask]s represent work which will be done after some delay. (Sometimes the delay is - * approximate such as on next available animation frame). Typically these methods include: - * `setTimeout`, `setImmediate`, `setInterval`, `requestAnimationFrame`, and all browser specific - * variants. - * - * - * ### [EventTask] - * - * [EventTask]s represent a request to create a listener on an event. Unlike the other task - * events they may never be executed, but typically execute more than once. There is no queue of - * events, rather their callbacks are unpredictable both in order and time. - * - * - * ## Global Error Handling - * - * - * ## Composability - * - * Zones can be composed together through [Zone.fork()]. A child zone may create its own set of - * rules. A child zone is expected to either: - * - * 1. Delegate the interception to a parent zone, and optionally add before and after wrapCallback - * hooks. - * 2. Process the request itself without delegation. - * - * Composability allows zones to keep their concerns clean. For example a top most zone may choose - * to handle error handling, while child zones may choose to do user action tracking. - * - * - * ## Root Zone - * - * At the start the browser will run in a special root zone, which is configured to behave exactly - * like the platform, making any existing code which is not zone-aware behave as expected. All - * zones are children of the root zone. - * - */ -interface Zone { +declare global { /** + * Zone is a mechanism for intercepting and keeping track of asynchronous work. * - * @returns {Zone} The parent Zone. - */ - parent: Zone|null; - /** - * @returns {string} The Zone name (useful for debugging) - */ - name: string; - - /** - * Returns a value associated with the `key`. + * A Zone is a global object which is configured with rules about how to intercept and keep track + * of the asynchronous callbacks. Zone has these responsibilities: * - * If the current zone does not have a key, the request is delegated to the parent zone. Use - * [ZoneSpec.properties] to configure the set of properties associated with the current zone. + * 1. Intercept asynchronous task scheduling + * 2. Wrap callbacks for error-handling and zone tracking across async operations. + * 3. Provide a way to attach data to zones + * 4. Provide a context specific last frame error handling + * 5. (Intercept blocking methods) * - * @param key The key to retrieve. - * @returns {any} The value for the key, or `undefined` if not found. - */ - get(key: string): any; - - /** - * Returns a Zone which defines a `key`. + * A zone by itself does not do anything, instead it relies on some other code to route existing + * platform API through it. (The zone library ships with code which monkey patches all of the + * browsers's asynchronous API and redirects them through the zone for interception.) * - * Recursively search the parent Zone until a Zone which has a property `key` is found. + * In its simplest form a zone allows one to intercept the scheduling and calling of asynchronous + * operations, and execute additional code before as well as after the asynchronous task. The + * rules of interception are configured using [ZoneConfig]. There can be many different zone + * instances in a system, but only one zone is active at any given time which can be retrieved + * using [Zone#current]. * - * @param key The key to use for identification of the returned zone. - * @returns {Zone} The Zone which defines the `key`, `null` if not found. - */ - getZoneWith(key: string): Zone|null; - - /** - * Used to create a child zone. * - * @param zoneSpec A set of rules which the child zone should follow. - * @returns {Zone} A new child zone. - */ - fork(zoneSpec: ZoneSpec): Zone; - - /** - * Wraps a callback function in a new function which will properly restore the current zone upon - * invocation. * - * The wrapped function will properly forward `this` as well as `arguments` to the `callback`. + * ## Callback Wrapping * - * Before the function is wrapped the zone can intercept the `callback` by declaring - * [ZoneSpec.onIntercept]. + * An important aspect of the zones is that they should persist across asynchronous operations. To + * achieve this, when a future work is scheduled through async API, it is necessary to capture, + * and subsequently restore the current zone. For example if a code is running in zone `b` and it + * invokes `setTimeout` to scheduleTask work later, the `setTimeout` method needs to 1) capture + * the current zone and 2) wrap the `wrapCallback` in code which will restore the current zone `b` + * once the wrapCallback executes. In this way the rules which govern the current code are + * preserved in all future asynchronous tasks. There could be a different zone `c` which has + * different rules and is associated with different asynchronous tasks. As these tasks are + * processed, each asynchronous wrapCallback correctly restores the correct zone, as well as + * preserves the zone for future asynchronous callbacks. * - * @param callback the function which will be wrapped in the zone. - * @param source A unique debug location of the API being wrapped. - * @returns {function(): *} A function which will invoke the `callback` through [Zone.runGuarded]. - */ - wrap(callback: F, source: string): F; - - /** - * Invokes a function in a given zone. + * Example: Suppose a browser page consist of application code as well as third-party + * advertisement code. (These two code bases are independent, developed by different mutually + * unaware developers.) The application code may be interested in doing global error handling and + * so it configures the `app` zone to send all of the errors to the server for analysis, and then + * executes the application in the `app` zone. The advertising code is interested in the same + * error processing but it needs to send the errors to a different third-party. So it creates the + * `ads` zone with a different error handler. Now both advertising as well as application code + * create many asynchronous operations, but the [Zone] will ensure that all of the asynchronous + * operations created from the application code will execute in `app` zone with its error + * handler and all of the advertisement code will execute in the `ads` zone with its error + * handler. This will not only work for the async operations created directly, but also for all + * subsequent asynchronous operations. * - * The invocation of `callback` can be intercepted by declaring [ZoneSpec.onInvoke]. + * If you think of chain of asynchronous operations as a thread of execution (bit of a stretch) + * then [Zone#current] will act as a thread local variable. * - * @param callback The function to invoke. - * @param applyThis - * @param applyArgs - * @param source A unique debug location of the API being invoked. - * @returns {any} Value from the `callback` function. - */ - run(callback: Function, applyThis?: any, applyArgs?: any[], source?: string): T; - - /** - * Invokes a function in a given zone and catches any exceptions. * - * Any exceptions thrown will be forwarded to [Zone.HandleError]. * - * The invocation of `callback` can be intercepted by declaring [ZoneSpec.onInvoke]. The - * handling of exceptions can be intercepted by declaring [ZoneSpec.handleError]. + * ## Asynchronous operation scheduling * - * @param callback The function to invoke. - * @param applyThis - * @param applyArgs - * @param source A unique debug location of the API being invoked. - * @returns {any} Value from the `callback` function. - */ - runGuarded(callback: Function, applyThis?: any, applyArgs?: any[], source?: string): T; - - /** - * Execute the Task by restoring the [Zone.currentTask] in the Task's zone. + * In addition to wrapping the callbacks to restore the zone, all operations which cause a + * scheduling of work for later are routed through the current zone which is allowed to intercept + * them by adding work before or after the wrapCallback as well as using different means of + * achieving the request. (Useful for unit testing, or tracking of requests). In some instances + * such as `setTimeout` the wrapping of the wrapCallback and scheduling is done in the same + * wrapCallback, but there are other examples such as `Promises` where the `then` wrapCallback is + * wrapped, but the execution of `then` is triggered by `Promise` scheduling `resolve` work. * - * @param task to run - * @param applyThis - * @param applyArgs - * @returns {any} Value from the `task.callback` function. - */ - runTask(task: Task, applyThis?: any, applyArgs?: any): T; - - /** - * Schedule a MicroTask. + * Fundamentally there are three kinds of tasks which can be scheduled: * - * @param source - * @param callback - * @param data - * @param customSchedule - */ - scheduleMicroTask( - source: string, callback: Function, data?: TaskData, - customSchedule?: (task: Task) => void): MicroTask; - - /** - * Schedule a MacroTask. + * 1. [MicroTask] used for doing work right after the current task. This is non-cancelable which + * is guaranteed to run exactly once and immediately. + * 2. [MacroTask] used for doing work later. Such as `setTimeout`. This is typically cancelable + * which is guaranteed to execute at least once after some well understood delay. + * 3. [EventTask] used for listening on some future event. This may execute zero or more times, + * with an unknown delay. * - * @param source - * @param callback - * @param data - * @param customSchedule - * @param customCancel - */ - scheduleMacroTask( - source: string, callback: Function, data?: TaskData, customSchedule?: (task: Task) => void, - customCancel?: (task: Task) => void): MacroTask; - - /** - * Schedule an EventTask. + * Each asynchronous API is modeled and routed through one of these APIs. * - * @param source - * @param callback - * @param data - * @param customSchedule - * @param customCancel - */ - scheduleEventTask( - source: string, callback: Function, data?: TaskData, customSchedule?: (task: Task) => void, - customCancel?: (task: Task) => void): EventTask; - - /** - * Schedule an existing Task. * - * Useful for rescheduling a task which was already canceled. + * ### [MicroTask] * - * @param task - */ - scheduleTask(task: T): T; - - /** - * Allows the zone to intercept canceling of scheduled Task. + * [MicroTask]s represent work which will be done in current VM turn as soon as possible, before + * VM yielding. * - * The interception is configured using [ZoneSpec.onCancelTask]. The default canceler invokes - * the [Task.cancelFn]. * - * @param task - * @returns {any} - */ - cancelTask(task: Task): any; -} - -interface ZoneType { - /** - * @returns {Zone} Returns the current [Zone]. The only way to change - * the current zone is by invoking a run() method, which will update the current zone for the - * duration of the run method callback. - */ - current: Zone; - - /** - * @returns {Task} The task associated with the current execution. - */ - currentTask: Task|null; - - /** - * Verify that Zone has been correctly patched. Specifically that Promise is zone aware. - */ - assertZonePatched(): void; - - /** - * Return the root zone. - */ - root: Zone; - - /** - * load patch for specified native module, allow user to - * define their own patch, user can use this API after loading zone.js - */ - __load_patch(name: string, fn: _PatchFn, ignoreDuplicate?: boolean): void; - - /** - * Zone symbol API to generate a string with __zone_symbol__ prefix - */ - __symbol__(name: string): string; -} - -/** - * Patch Function to allow user define their own monkey patch module. - */ -type _PatchFn = (global: Window, Zone: ZoneType, api: _ZonePrivate) => void; - -/** - * _ZonePrivate interface to provide helper method to help user implement - * their own monkey patch module. - */ -interface _ZonePrivate { - currentZoneFrame: () => _ZoneFrame; - symbol: (name: string) => string; - scheduleMicroTask: (task?: MicroTask) => void; - onUnhandledError: (error: Error) => void; - microtaskDrainDone: () => void; - showUncaughtError: () => boolean; - patchEventTarget: (global: any, api: _ZonePrivate, apis: any[], options?: any) => boolean[]; - patchOnProperties: (obj: any, properties: string[]|null, prototype?: any) => void; - patchThen: (ctro: Function) => void; - patchMethod: - (target: any, name: string, - patchFn: (delegate: Function, delegateName: string, name: string) => - (self: any, args: any[]) => any) => Function | null; - bindArguments: (args: any[], source: string) => any[]; - patchMacroTask: - (obj: any, funcName: string, metaCreator: (self: any, args: any[]) => any) => void; - patchEventPrototype: (_global: any, api: _ZonePrivate) => void; - isIEOrEdge: () => boolean; - ObjectDefineProperty: - (o: any, p: PropertyKey, attributes: PropertyDescriptor&ThisType) => any; - ObjectGetOwnPropertyDescriptor: (o: any, p: PropertyKey) => PropertyDescriptor | undefined; - ObjectCreate(o: object|null, properties?: PropertyDescriptorMap&ThisType): any; - ArraySlice(start?: number, end?: number): any[]; - patchClass: (className: string) => void; - wrapWithCurrentZone: (callback: any, source: string) => any; - filterProperties: (target: any, onProperties: string[], ignoreProperties: any[]) => string[]; - attachOriginToPatched: (target: any, origin: any) => void; - _redefineProperty: (target: any, callback: string, desc: any) => void; - nativeScheduleMicroTask: (func: Function) => void; - patchCallbacks: - (api: _ZonePrivate, target: any, targetName: string, method: string, - callbacks: string[]) => void; - getGlobalObjects: () => { - globalSources: any, zoneSymbolEventNames: any, eventNames: string[], isBrowser: boolean, - isMix: boolean, isNode: boolean, TRUE_STR: string, FALSE_STR: string, - ZONE_SYMBOL_PREFIX: string, ADD_EVENT_LISTENER_STR: string, - REMOVE_EVENT_LISTENER_STR: string - } | undefined; -} - -/** - * _ZoneFrame represents zone stack frame information - */ -interface _ZoneFrame { - parent: _ZoneFrame|null; - zone: Zone; -} - -interface UncaughtPromiseError extends Error { - zone: Zone; - task: Task; - promise: Promise; - rejection: any; - throwOriginal?: boolean; -} - -/** - * Provides a way to configure the interception of zone events. - * - * Only the `name` property is required (all other are optional). - */ -interface ZoneSpec { - /** - * The name of the zone. Useful when debugging Zones. - */ - name: string; - - /** - * A set of properties to be associated with Zone. Use [Zone.get] to retrieve them. - */ - properties?: {[key: string]: any}; - - /** - * Allows the interception of zone forking. + * ### [MacroTask] * - * When the zone is being forked, the request is forwarded to this method for interception. + * [MacroTask]s represent work which will be done after some delay. (Sometimes the delay is + * approximate such as on next available animation frame). Typically these methods include: + * `setTimeout`, `setImmediate`, `setInterval`, `requestAnimationFrame`, and all browser specific + * variants. * - * @param parentZoneDelegate Delegate which performs the parent [ZoneSpec] operation. - * @param currentZone The current [Zone] where the current interceptor has been declared. - * @param targetZone The [Zone] which originally received the request. - * @param zoneSpec The argument passed into the `fork` method. - */ - onFork?: - (parentZoneDelegate: ZoneDelegate, currentZone: Zone, targetZone: Zone, - zoneSpec: ZoneSpec) => Zone; - - /** - * Allows interception of the wrapping of the callback. * - * @param parentZoneDelegate Delegate which performs the parent [ZoneSpec] operation. - * @param currentZone The current [Zone] where the current interceptor has been declared. - * @param targetZone The [Zone] which originally received the request. - * @param delegate The argument passed into the `wrap` method. - * @param source The argument passed into the `wrap` method. - */ - onIntercept?: - (parentZoneDelegate: ZoneDelegate, currentZone: Zone, targetZone: Zone, delegate: Function, - source: string) => Function; - - /** - * Allows interception of the callback invocation. + * ### [EventTask] * - * @param parentZoneDelegate Delegate which performs the parent [ZoneSpec] operation. - * @param currentZone The current [Zone] where the current interceptor has been declared. - * @param targetZone The [Zone] which originally received the request. - * @param delegate The argument passed into the `run` method. - * @param applyThis The argument passed into the `run` method. - * @param applyArgs The argument passed into the `run` method. - * @param source The argument passed into the `run` method. - */ - onInvoke?: - (parentZoneDelegate: ZoneDelegate, currentZone: Zone, targetZone: Zone, delegate: Function, - applyThis: any, applyArgs?: any[], source?: string) => any; - - /** - * Allows interception of the error handling. + * [EventTask]s represent a request to create a listener on an event. Unlike the other task + * events they may never be executed, but typically execute more than once. There is no queue of + * events, rather their callbacks are unpredictable both in order and time. * - * @param parentZoneDelegate Delegate which performs the parent [ZoneSpec] operation. - * @param currentZone The current [Zone] where the current interceptor has been declared. - * @param targetZone The [Zone] which originally received the request. - * @param error The argument passed into the `handleError` method. - */ - onHandleError?: - (parentZoneDelegate: ZoneDelegate, currentZone: Zone, targetZone: Zone, - error: any) => boolean; - - /** - * Allows interception of task scheduling. * - * @param parentZoneDelegate Delegate which performs the parent [ZoneSpec] operation. - * @param currentZone The current [Zone] where the current interceptor has been declared. - * @param targetZone The [Zone] which originally received the request. - * @param task The argument passed into the `scheduleTask` method. - */ - onScheduleTask?: - (parentZoneDelegate: ZoneDelegate, currentZone: Zone, targetZone: Zone, task: Task) => Task; - - onInvokeTask?: - (parentZoneDelegate: ZoneDelegate, currentZone: Zone, targetZone: Zone, task: Task, - applyThis: any, applyArgs?: any[]) => any; - - /** - * Allows interception of task cancellation. + * ## Global Error Handling * - * @param parentZoneDelegate Delegate which performs the parent [ZoneSpec] operation. - * @param currentZone The current [Zone] where the current interceptor has been declared. - * @param targetZone The [Zone] which originally received the request. - * @param task The argument passed into the `cancelTask` method. - */ - onCancelTask?: - (parentZoneDelegate: ZoneDelegate, currentZone: Zone, targetZone: Zone, task: Task) => any; - - /** - * Notifies of changes to the task queue empty status. * - * @param parentZoneDelegate Delegate which performs the parent [ZoneSpec] operation. - * @param currentZone The current [Zone] where the current interceptor has been declared. - * @param targetZone The [Zone] which originally received the request. - * @param hasTaskState + * ## Composability + * + * Zones can be composed together through [Zone.fork()]. A child zone may create its own set of + * rules. A child zone is expected to either: + * + * 1. Delegate the interception to a parent zone, and optionally add before and after wrapCallback + * hooks. + * 2. Process the request itself without delegation. + * + * Composability allows zones to keep their concerns clean. For example a top most zone may choose + * to handle error handling, while child zones may choose to do user action tracking. + * + * + * ## Root Zone + * + * At the start the browser will run in a special root zone, which is configured to behave exactly + * like the platform, making any existing code which is not zone-aware behave as expected. All + * zones are children of the root zone. + * */ - onHasTask?: - (parentZoneDelegate: ZoneDelegate, currentZone: Zone, targetZone: Zone, - hasTaskState: HasTaskState) => void; -} + interface Zone { + /** + * + * @returns {Zone} The parent Zone. + */ + parent: Zone|null; + /** + * @returns {string} The Zone name (useful for debugging) + */ + name: string; + /** + * Returns a value associated with the `key`. + * + * If the current zone does not have a key, the request is delegated to the parent zone. Use + * [ZoneSpec.properties] to configure the set of properties associated with the current zone. + * + * @param key The key to retrieve. + * @returns {any} The value for the key, or `undefined` if not found. + */ + get(key: string): any; -/** - * A delegate when intercepting zone operations. - * - * A ZoneDelegate is needed because a child zone can't simply invoke a method on a parent zone. For - * example a child zone wrap can't just call parent zone wrap. Doing so would create a callback - * which is bound to the parent zone. What we are interested in is intercepting the callback before - * it is bound to any zone. Furthermore, we also need to pass the targetZone (zone which received - * the original request) to the delegate. - * - * The ZoneDelegate methods mirror those of Zone with an addition of extra targetZone argument in - * the method signature. (The original Zone which received the request.) Some methods are renamed - * to prevent confusion, because they have slightly different semantics and arguments. - * - * - `wrap` => `intercept`: The `wrap` method delegates to `intercept`. The `wrap` method returns - * a callback which will run in a given zone, where as intercept allows wrapping the callback - * so that additional code can be run before and after, but does not associate the callback - * with the zone. - * - `run` => `invoke`: The `run` method delegates to `invoke` to perform the actual execution of - * the callback. The `run` method switches to new zone; saves and restores the `Zone.current`; - * and optionally performs error handling. The invoke is not responsible for error handling, - * or zone management. - * - * Not every method is usually overwritten in the child zone, for this reason the ZoneDelegate - * stores the closest zone which overwrites this behavior along with the closest ZoneSpec. - * - * NOTE: We have tried to make this API analogous to Event bubbling with target and current - * properties. - * - * Note: The ZoneDelegate treats ZoneSpec as class. This allows the ZoneSpec to use its `this` to - * store internal state. - */ -interface ZoneDelegate { - zone: Zone; - fork(targetZone: Zone, zoneSpec: ZoneSpec): Zone; - intercept(targetZone: Zone, callback: Function, source: string): Function; - invoke(targetZone: Zone, callback: Function, applyThis?: any, applyArgs?: any[], source?: string): - any; - handleError(targetZone: Zone, error: any): boolean; - scheduleTask(targetZone: Zone, task: Task): Task; - invokeTask(targetZone: Zone, task: Task, applyThis?: any, applyArgs?: any[]): any; - cancelTask(targetZone: Zone, task: Task): any; - hasTask(targetZone: Zone, isEmpty: HasTaskState): void; -} + /** + * Returns a Zone which defines a `key`. + * + * Recursively search the parent Zone until a Zone which has a property `key` is found. + * + * @param key The key to use for identification of the returned zone. + * @returns {Zone} The Zone which defines the `key`, `null` if not found. + */ + getZoneWith(key: string): Zone|null; -type HasTaskState = { - microTask: boolean; macroTask: boolean; eventTask: boolean; change: TaskType; -}; + /** + * Used to create a child zone. + * + * @param zoneSpec A set of rules which the child zone should follow. + * @returns {Zone} A new child zone. + */ + fork(zoneSpec: ZoneSpec): Zone; -/** - * Task type: `microTask`, `macroTask`, `eventTask`. - */ -type TaskType = 'microTask'|'macroTask'|'eventTask'; + /** + * Wraps a callback function in a new function which will properly restore the current zone upon + * invocation. + * + * The wrapped function will properly forward `this` as well as `arguments` to the `callback`. + * + * Before the function is wrapped the zone can intercept the `callback` by declaring + * [ZoneSpec.onIntercept]. + * + * @param callback the function which will be wrapped in the zone. + * @param source A unique debug location of the API being wrapped. + * @returns {function(): *} A function which will invoke the `callback` through + * [Zone.runGuarded]. + */ + wrap(callback: F, source: string): F; -/** - * Task type: `notScheduled`, `scheduling`, `scheduled`, `running`, `canceling`, 'unknown'. - */ -type TaskState = 'notScheduled'|'scheduling'|'scheduled'|'running'|'canceling'|'unknown'; + /** + * Invokes a function in a given zone. + * + * The invocation of `callback` can be intercepted by declaring [ZoneSpec.onInvoke]. + * + * @param callback The function to invoke. + * @param applyThis + * @param applyArgs + * @param source A unique debug location of the API being invoked. + * @returns {any} Value from the `callback` function. + */ + run(callback: Function, applyThis?: any, applyArgs?: any[], source?: string): T; + /** + * Invokes a function in a given zone and catches any exceptions. + * + * Any exceptions thrown will be forwarded to [Zone.HandleError]. + * + * The invocation of `callback` can be intercepted by declaring [ZoneSpec.onInvoke]. The + * handling of exceptions can be intercepted by declaring [ZoneSpec.handleError]. + * + * @param callback The function to invoke. + * @param applyThis + * @param applyArgs + * @param source A unique debug location of the API being invoked. + * @returns {any} Value from the `callback` function. + */ + runGuarded(callback: Function, applyThis?: any, applyArgs?: any[], source?: string): T; -/** - */ -interface TaskData { - /** - * A periodic [MacroTask] is such which get automatically rescheduled after it is executed. - */ - isPeriodic?: boolean; + /** + * Execute the Task by restoring the [Zone.currentTask] in the Task's zone. + * + * @param task to run + * @param applyThis + * @param applyArgs + * @returns {any} Value from the `task.callback` function. + */ + runTask(task: Task, applyThis?: any, applyArgs?: any): T; + + /** + * Schedule a MicroTask. + * + * @param source + * @param callback + * @param data + * @param customSchedule + */ + scheduleMicroTask( + source: string, callback: Function, data?: TaskData, + customSchedule?: (task: Task) => void): MicroTask; + + /** + * Schedule a MacroTask. + * + * @param source + * @param callback + * @param data + * @param customSchedule + * @param customCancel + */ + scheduleMacroTask( + source: string, callback: Function, data?: TaskData, customSchedule?: (task: Task) => void, + customCancel?: (task: Task) => void): MacroTask; + + /** + * Schedule an EventTask. + * + * @param source + * @param callback + * @param data + * @param customSchedule + * @param customCancel + */ + scheduleEventTask( + source: string, callback: Function, data?: TaskData, customSchedule?: (task: Task) => void, + customCancel?: (task: Task) => void): EventTask; + + /** + * Schedule an existing Task. + * + * Useful for rescheduling a task which was already canceled. + * + * @param task + */ + scheduleTask(task: T): T; + + /** + * Allows the zone to intercept canceling of scheduled Task. + * + * The interception is configured using [ZoneSpec.onCancelTask]. The default canceler invokes + * the [Task.cancelFn]. + * + * @param task + * @returns {any} + */ + cancelTask(task: Task): any; + } + + interface ZoneType { + /** + * @returns {Zone} Returns the current [Zone]. The only way to change + * the current zone is by invoking a run() method, which will update the current zone for the + * duration of the run method callback. + */ + current: Zone; + + /** + * @returns {Task} The task associated with the current execution. + */ + currentTask: Task|null; + + /** + * Verify that Zone has been correctly patched. Specifically that Promise is zone aware. + */ + assertZonePatched(): void; + + /** + * Return the root zone. + */ + root: Zone; + + /** + * load patch for specified native module, allow user to + * define their own patch, user can use this API after loading zone.js + */ + __load_patch(name: string, fn: _PatchFn, ignoreDuplicate?: boolean): void; + + /** + * Zone symbol API to generate a string with __zone_symbol__ prefix + */ + __symbol__(name: string): string; + } /** - * Delay in milliseconds when the Task will run. + * Patch Function to allow user define their own monkey patch module. */ - delay?: number; + type _PatchFn = (global: Window, Zone: ZoneType, api: _ZonePrivate) => void; /** - * identifier returned by the native setTimeout. + * _ZonePrivate interface to provide helper method to help user implement + * their own monkey patch module. */ - handleId?: number; -} + interface _ZonePrivate { + currentZoneFrame: () => _ZoneFrame; + symbol: (name: string) => string; + scheduleMicroTask: (task?: MicroTask) => void; + onUnhandledError: (error: Error) => void; + microtaskDrainDone: () => void; + showUncaughtError: () => boolean; + patchEventTarget: (global: any, api: _ZonePrivate, apis: any[], options?: any) => boolean[]; + patchOnProperties: (obj: any, properties: string[]|null, prototype?: any) => void; + patchThen: (ctro: Function) => void; + patchMethod: + (target: any, name: string, + patchFn: (delegate: Function, delegateName: string, name: string) => + (self: any, args: any[]) => any) => Function | null; + bindArguments: (args: any[], source: string) => any[]; + patchMacroTask: + (obj: any, funcName: string, metaCreator: (self: any, args: any[]) => any) => void; + patchEventPrototype: (_global: any, api: _ZonePrivate) => void; + isIEOrEdge: () => boolean; + ObjectDefineProperty: + (o: any, p: PropertyKey, attributes: PropertyDescriptor&ThisType) => any; + ObjectGetOwnPropertyDescriptor: (o: any, p: PropertyKey) => PropertyDescriptor | undefined; + ObjectCreate(o: object|null, properties?: PropertyDescriptorMap&ThisType): any; + ArraySlice(start?: number, end?: number): any[]; + patchClass: (className: string) => void; + wrapWithCurrentZone: (callback: any, source: string) => any; + filterProperties: (target: any, onProperties: string[], ignoreProperties: any[]) => string[]; + attachOriginToPatched: (target: any, origin: any) => void; + _redefineProperty: (target: any, callback: string, desc: any) => void; + nativeScheduleMicroTask: (func: Function) => void; + patchCallbacks: + (api: _ZonePrivate, target: any, targetName: string, method: string, + callbacks: string[]) => void; + getGlobalObjects: () => { + globalSources: any, zoneSymbolEventNames: any, eventNames: string[], isBrowser: boolean, + isMix: boolean, isNode: boolean, TRUE_STR: string, FALSE_STR: string, + ZONE_SYMBOL_PREFIX: string, ADD_EVENT_LISTENER_STR: string, + REMOVE_EVENT_LISTENER_STR: string + } | undefined; + } + + /** + * _ZoneFrame represents zone stack frame information + */ + interface _ZoneFrame { + parent: _ZoneFrame|null; + zone: Zone; + } + + interface UncaughtPromiseError extends Error { + zone: Zone; + task: Task; + promise: Promise; + rejection: any; + throwOriginal?: boolean; + } + + /** + * Provides a way to configure the interception of zone events. + * + * Only the `name` property is required (all other are optional). + */ + interface ZoneSpec { + /** + * The name of the zone. Useful when debugging Zones. + */ + name: string; + + /** + * A set of properties to be associated with Zone. Use [Zone.get] to retrieve them. + */ + properties?: {[key: string]: any}; + + /** + * Allows the interception of zone forking. + * + * When the zone is being forked, the request is forwarded to this method for interception. + * + * @param parentZoneDelegate Delegate which performs the parent [ZoneSpec] operation. + * @param currentZone The current [Zone] where the current interceptor has been declared. + * @param targetZone The [Zone] which originally received the request. + * @param zoneSpec The argument passed into the `fork` method. + */ + onFork?: + (parentZoneDelegate: ZoneDelegate, currentZone: Zone, targetZone: Zone, + zoneSpec: ZoneSpec) => Zone; + + /** + * Allows interception of the wrapping of the callback. + * + * @param parentZoneDelegate Delegate which performs the parent [ZoneSpec] operation. + * @param currentZone The current [Zone] where the current interceptor has been declared. + * @param targetZone The [Zone] which originally received the request. + * @param delegate The argument passed into the `wrap` method. + * @param source The argument passed into the `wrap` method. + */ + onIntercept?: + (parentZoneDelegate: ZoneDelegate, currentZone: Zone, targetZone: Zone, delegate: Function, + source: string) => Function; + + /** + * Allows interception of the callback invocation. + * + * @param parentZoneDelegate Delegate which performs the parent [ZoneSpec] operation. + * @param currentZone The current [Zone] where the current interceptor has been declared. + * @param targetZone The [Zone] which originally received the request. + * @param delegate The argument passed into the `run` method. + * @param applyThis The argument passed into the `run` method. + * @param applyArgs The argument passed into the `run` method. + * @param source The argument passed into the `run` method. + */ + onInvoke?: + (parentZoneDelegate: ZoneDelegate, currentZone: Zone, targetZone: Zone, delegate: Function, + applyThis: any, applyArgs?: any[], source?: string) => any; + + /** + * Allows interception of the error handling. + * + * @param parentZoneDelegate Delegate which performs the parent [ZoneSpec] operation. + * @param currentZone The current [Zone] where the current interceptor has been declared. + * @param targetZone The [Zone] which originally received the request. + * @param error The argument passed into the `handleError` method. + */ + onHandleError?: + (parentZoneDelegate: ZoneDelegate, currentZone: Zone, targetZone: Zone, + error: any) => boolean; + + /** + * Allows interception of task scheduling. + * + * @param parentZoneDelegate Delegate which performs the parent [ZoneSpec] operation. + * @param currentZone The current [Zone] where the current interceptor has been declared. + * @param targetZone The [Zone] which originally received the request. + * @param task The argument passed into the `scheduleTask` method. + */ + onScheduleTask?: + (parentZoneDelegate: ZoneDelegate, currentZone: Zone, targetZone: Zone, task: Task) => Task; + + onInvokeTask?: + (parentZoneDelegate: ZoneDelegate, currentZone: Zone, targetZone: Zone, task: Task, + applyThis: any, applyArgs?: any[]) => any; + + /** + * Allows interception of task cancellation. + * + * @param parentZoneDelegate Delegate which performs the parent [ZoneSpec] operation. + * @param currentZone The current [Zone] where the current interceptor has been declared. + * @param targetZone The [Zone] which originally received the request. + * @param task The argument passed into the `cancelTask` method. + */ + onCancelTask?: + (parentZoneDelegate: ZoneDelegate, currentZone: Zone, targetZone: Zone, task: Task) => any; + + /** + * Notifies of changes to the task queue empty status. + * + * @param parentZoneDelegate Delegate which performs the parent [ZoneSpec] operation. + * @param currentZone The current [Zone] where the current interceptor has been declared. + * @param targetZone The [Zone] which originally received the request. + * @param hasTaskState + */ + onHasTask?: + (parentZoneDelegate: ZoneDelegate, currentZone: Zone, targetZone: Zone, + hasTaskState: HasTaskState) => void; + } + + + /** + * A delegate when intercepting zone operations. + * + * A ZoneDelegate is needed because a child zone can't simply invoke a method on a parent zone. + * For example a child zone wrap can't just call parent zone wrap. Doing so would create a + * callback which is bound to the parent zone. What we are interested in is intercepting the + * callback before it is bound to any zone. Furthermore, we also need to pass the targetZone (zone + * which received the original request) to the delegate. + * + * The ZoneDelegate methods mirror those of Zone with an addition of extra targetZone argument in + * the method signature. (The original Zone which received the request.) Some methods are renamed + * to prevent confusion, because they have slightly different semantics and arguments. + * + * - `wrap` => `intercept`: The `wrap` method delegates to `intercept`. The `wrap` method returns + * a callback which will run in a given zone, where as intercept allows wrapping the callback + * so that additional code can be run before and after, but does not associate the callback + * with the zone. + * - `run` => `invoke`: The `run` method delegates to `invoke` to perform the actual execution of + * the callback. The `run` method switches to new zone; saves and restores the `Zone.current`; + * and optionally performs error handling. The invoke is not responsible for error handling, + * or zone management. + * + * Not every method is usually overwritten in the child zone, for this reason the ZoneDelegate + * stores the closest zone which overwrites this behavior along with the closest ZoneSpec. + * + * NOTE: We have tried to make this API analogous to Event bubbling with target and current + * properties. + * + * Note: The ZoneDelegate treats ZoneSpec as class. This allows the ZoneSpec to use its `this` to + * store internal state. + */ + interface ZoneDelegate { + zone: Zone; + fork(targetZone: Zone, zoneSpec: ZoneSpec): Zone; + intercept(targetZone: Zone, callback: Function, source: string): Function; + invoke( + targetZone: Zone, callback: Function, applyThis?: any, applyArgs?: any[], + source?: string): any; + handleError(targetZone: Zone, error: any): boolean; + scheduleTask(targetZone: Zone, task: Task): Task; + invokeTask(targetZone: Zone, task: Task, applyThis?: any, applyArgs?: any[]): any; + cancelTask(targetZone: Zone, task: Task): any; + hasTask(targetZone: Zone, isEmpty: HasTaskState): void; + } + + type HasTaskState = { + microTask: boolean; macroTask: boolean; eventTask: boolean; change: TaskType; + }; -/** - * Represents work which is executed with a clean stack. - * - * Tasks are used in Zones to mark work which is performed on clean stack frame. There are three - * kinds of task. [MicroTask], [MacroTask], and [EventTask]. - * - * A JS VM can be modeled as a [MicroTask] queue, [MacroTask] queue, and [EventTask] set. - * - * - [MicroTask] queue represents a set of tasks which are executing right after the current stack - * frame becomes clean and before a VM yield. All [MicroTask]s execute in order of insertion - * before VM yield and the next [MacroTask] is executed. - * - [MacroTask] queue represents a set of tasks which are executed one at a time after each VM - * yield. The queue is ordered by time, and insertions can happen in any location. - * - [EventTask] is a set of tasks which can at any time be inserted to the end of the [MacroTask] - * queue. This happens when the event fires. - * - */ -interface Task { /** * Task type: `microTask`, `macroTask`, `eventTask`. */ - type: TaskType; + type TaskType = 'microTask'|'macroTask'|'eventTask'; /** - * Task state: `notScheduled`, `scheduling`, `scheduled`, `running`, `canceling`, `unknown`. + * Task type: `notScheduled`, `scheduling`, `scheduled`, `running`, `canceling`, 'unknown'. */ - state: TaskState; + type TaskState = 'notScheduled'|'scheduling'|'scheduled'|'running'|'canceling'|'unknown'; + /** - * Debug string representing the API which requested the scheduling of the task. */ - source: string; + interface TaskData { + /** + * A periodic [MacroTask] is such which get automatically rescheduled after it is executed. + */ + isPeriodic?: boolean; + + /** + * Delay in milliseconds when the Task will run. + */ + delay?: number; + + /** + * identifier returned by the native setTimeout. + */ + handleId?: number; + } /** - * The Function to be used by the VM upon entering the [Task]. This function will delegate to - * [Zone.runTask] and delegate to `callback`. - */ - invoke: Function; - - /** - * Function which needs to be executed by the Task after the [Zone.currentTask] has been set to - * the current task. - */ - callback: Function; - - /** - * Task specific options associated with the current task. This is passed to the `scheduleFn`. - */ - data?: TaskData; - - /** - * Represents the default work which needs to be done to schedule the Task by the VM. + * Represents work which is executed with a clean stack. * - * A zone may choose to intercept this function and perform its own scheduling. - */ - scheduleFn?: (task: Task) => void; - - /** - * Represents the default work which needs to be done to un-schedule the Task from the VM. Not all - * Tasks are cancelable, and therefore this method is optional. + * Tasks are used in Zones to mark work which is performed on clean stack frame. There are three + * kinds of task. [MicroTask], [MacroTask], and [EventTask]. + * + * A JS VM can be modeled as a [MicroTask] queue, [MacroTask] queue, and [EventTask] set. + * + * - [MicroTask] queue represents a set of tasks which are executing right after the current stack + * frame becomes clean and before a VM yield. All [MicroTask]s execute in order of insertion + * before VM yield and the next [MacroTask] is executed. + * - [MacroTask] queue represents a set of tasks which are executed one at a time after each VM + * yield. The queue is ordered by time, and insertions can happen in any location. + * - [EventTask] is a set of tasks which can at any time be inserted to the end of the [MacroTask] + * queue. This happens when the event fires. * - * A zone may chose to intercept this function and perform its own un-scheduling. */ - cancelFn?: (task: Task) => void; + interface Task { + /** + * Task type: `microTask`, `macroTask`, `eventTask`. + */ + type: TaskType; - /** - * @type {Zone} The zone which will be used to invoke the `callback`. The Zone is captured - * at the time of Task creation. - */ - readonly zone: Zone; + /** + * Task state: `notScheduled`, `scheduling`, `scheduled`, `running`, `canceling`, `unknown`. + */ + state: TaskState; - /** - * Number of times the task has been executed, or -1 if canceled. - */ - runCount: number; + /** + * Debug string representing the API which requested the scheduling of the task. + */ + source: string; - /** - * Cancel the scheduling request. This method can be called from `ZoneSpec.onScheduleTask` to - * cancel the current scheduling interception. Once canceled the task can be discarded or - * rescheduled using `Zone.scheduleTask` on a different zone. - */ - cancelScheduleRequest(): void; -} + /** + * The Function to be used by the VM upon entering the [Task]. This function will delegate to + * [Zone.runTask] and delegate to `callback`. + */ + invoke: Function; -interface MicroTask extends Task { - type: 'microTask'; -} + /** + * Function which needs to be executed by the Task after the [Zone.currentTask] has been set to + * the current task. + */ + callback: Function; -interface MacroTask extends Task { - type: 'macroTask'; -} + /** + * Task specific options associated with the current task. This is passed to the `scheduleFn`. + */ + data?: TaskData; -interface EventTask extends Task { - type: 'eventTask'; -} + /** + * Represents the default work which needs to be done to schedule the Task by the VM. + * + * A zone may choose to intercept this function and perform its own scheduling. + */ + scheduleFn?: (task: Task) => void; -/** @internal */ -type AmbientZone = Zone; + /** + * Represents the default work which needs to be done to un-schedule the Task from the VM. Not + * all Tasks are cancelable, and therefore this method is optional. + * + * A zone may chose to intercept this function and perform its own un-scheduling. + */ + cancelFn?: (task: Task) => void; -const Zone: ZoneType = (function(global: any) { - const performance: {mark(name: string): void; measure(name: string, label: string): void;} = - global['performance']; - function mark(name: string) { - performance && performance['mark'] && performance['mark'](name); - } - function performanceMeasure(name: string, label: string) { - performance && performance['measure'] && performance['measure'](name, label); - } - mark('Zone'); + /** + * @type {Zone} The zone which will be used to invoke the `callback`. The Zone is captured + * at the time of Task creation. + */ + readonly zone: Zone; - // Initialize before it's accessed below. - // __Zone_symbol_prefix global can be used to override the default zone - // symbol prefix with a custom one if needed. - const symbolPrefix = global['__Zone_symbol_prefix'] || '__zone_symbol__'; + /** + * Number of times the task has been executed, or -1 if canceled. + */ + runCount: number; - function __symbol__(name: string) { - return symbolPrefix + name; + /** + * Cancel the scheduling request. This method can be called from `ZoneSpec.onScheduleTask` to + * cancel the current scheduling interception. Once canceled the task can be discarded or + * rescheduled using `Zone.scheduleTask` on a different zone. + */ + cancelScheduleRequest(): void; } - const checkDuplicate = global[__symbol__('forceDuplicateZoneCheck')] === true; - if (global['Zone']) { - // if global['Zone'] already exists (maybe zone.js was already loaded or - // some other lib also registered a global object named Zone), we may need - // to throw an error, but sometimes user may not want this error. - // For example, - // we have two web pages, page1 includes zone.js, page2 doesn't. - // and the 1st time user load page1 and page2, everything work fine, - // but when user load page2 again, error occurs because global['Zone'] already exists. - // so we add a flag to let user choose whether to throw this error or not. - // By default, if existing Zone is from zone.js, we will not throw the error. - if (checkDuplicate || typeof global['Zone'].__symbol__ !== 'function') { - throw new Error('Zone already loaded.'); - } else { - return global['Zone']; + interface MicroTask extends Task { + type: 'microTask'; + } + + interface MacroTask extends Task { + type: 'macroTask'; + } + + interface EventTask extends Task { + type: 'eventTask'; + } + + /** @internal */ + type AmbientZone = Zone; + + // Initialized below. + const Zone: ZoneType; +} + +// Initialize global `Zone` constant. +(function(global: any) { +const performance: {mark(name: string): void; measure(name: string, label: string): void;} = + global['performance']; +function mark(name: string) { + performance && performance['mark'] && performance['mark'](name); +} +function performanceMeasure(name: string, label: string) { + performance && performance['measure'] && performance['measure'](name, label); +} +mark('Zone'); + +// Initialize before it's accessed below. +// __Zone_symbol_prefix global can be used to override the default zone +// symbol prefix with a custom one if needed. +const symbolPrefix = global['__Zone_symbol_prefix'] || '__zone_symbol__'; + +function __symbol__(name: string) { + return symbolPrefix + name; +} + +const checkDuplicate = global[__symbol__('forceDuplicateZoneCheck')] === true; +if (global['Zone']) { + // if global['Zone'] already exists (maybe zone.js was already loaded or + // some other lib also registered a global object named Zone), we may need + // to throw an error, but sometimes user may not want this error. + // For example, + // we have two web pages, page1 includes zone.js, page2 doesn't. + // and the 1st time user load page1 and page2, everything work fine, + // but when user load page2 again, error occurs because global['Zone'] already exists. + // so we add a flag to let user choose whether to throw this error or not. + // By default, if existing Zone is from zone.js, we will not throw the error. + if (checkDuplicate || typeof global['Zone'].__symbol__ !== 'function') { + throw new Error('Zone already loaded.'); + } else { + return global['Zone']; + } +} + +class Zone implements AmbientZone { + // tslint:disable-next-line:require-internal-with-underscore + static __symbol__: (name: string) => string = __symbol__; + + static assertZonePatched() { + if (global['Promise'] !== patches['ZoneAwarePromise']) { + throw new Error( + 'Zone.js has detected that ZoneAwarePromise `(window|global).Promise` ' + + 'has been overwritten.\n' + + 'Most likely cause is that a Promise polyfill has been loaded ' + + 'after Zone.js (Polyfilling Promise api is not necessary when zone.js is loaded. ' + + 'If you must load one, do so before loading zone.js.)'); } } - class Zone implements AmbientZone { - // tslint:disable-next-line:require-internal-with-underscore - static __symbol__: (name: string) => string = __symbol__; + static get root(): AmbientZone { + let zone = Zone.current; + while (zone.parent) { + zone = zone.parent; + } + return zone; + } - static assertZonePatched() { - if (global['Promise'] !== patches['ZoneAwarePromise']) { - throw new Error( - 'Zone.js has detected that ZoneAwarePromise `(window|global).Promise` ' + - 'has been overwritten.\n' + - 'Most likely cause is that a Promise polyfill has been loaded ' + - 'after Zone.js (Polyfilling Promise api is not necessary when zone.js is loaded. ' + - 'If you must load one, do so before loading zone.js.)'); + static get current(): AmbientZone { + return _currentZoneFrame.zone; + } + + static get currentTask(): Task|null { + return _currentTask; + } + + // tslint:disable-next-line:require-internal-with-underscore + static __load_patch(name: string, fn: _PatchFn, ignoreDuplicate = false): void { + if (patches.hasOwnProperty(name)) { + // `checkDuplicate` option is defined from global variable + // so it works for all modules. + // `ignoreDuplicate` can work for the specified module + if (!ignoreDuplicate && checkDuplicate) { + throw Error('Already loaded patch: ' + name); } + } else if (!global['__Zone_disable_' + name]) { + const perfName = 'Zone:' + name; + mark(perfName); + patches[name] = fn(global, Zone, _api); + performanceMeasure(perfName, perfName); } + } - static get root(): AmbientZone { - let zone = Zone.current; - while (zone.parent) { - zone = zone.parent; + public get parent(): AmbientZone|null { + return this._parent; + } + + public get name(): string { + return this._name; + } + + + private _parent: Zone|null; + private _name: string; + private _properties: {[key: string]: any}; + private _zoneDelegate: _ZoneDelegate; + + constructor(parent: Zone|null, zoneSpec: ZoneSpec|null) { + this._parent = parent; + this._name = zoneSpec ? zoneSpec.name || 'unnamed' : ''; + this._properties = zoneSpec && zoneSpec.properties || {}; + this._zoneDelegate = + new _ZoneDelegate(this, this._parent && this._parent._zoneDelegate, zoneSpec); + } + + public get(key: string): any { + const zone: Zone = this.getZoneWith(key) as Zone; + if (zone) return zone._properties[key]; + } + + public getZoneWith(key: string): AmbientZone|null { + let current: Zone|null = this; + while (current) { + if (current._properties.hasOwnProperty(key)) { + return current; } - return zone; + current = current._parent; } + return null; + } - static get current(): AmbientZone { - return _currentZoneFrame.zone; + public fork(zoneSpec: ZoneSpec): AmbientZone { + if (!zoneSpec) throw new Error('ZoneSpec required!'); + return this._zoneDelegate.fork(this, zoneSpec); + } + + public wrap(callback: T, source: string): T { + if (typeof callback !== 'function') { + throw new Error('Expecting function got: ' + callback); } + const _callback = this._zoneDelegate.intercept(this, callback, source); + const zone: Zone = this; + return function(this: unknown) { + return zone.runGuarded(_callback, this, arguments, source); + } as any as T; + } - static get currentTask(): Task|null { - return _currentTask; + public run(callback: Function, applyThis?: any, applyArgs?: any[], source?: string): any; + public run( + callback: (...args: any[]) => T, applyThis?: any, applyArgs?: any[], source?: string): T { + _currentZoneFrame = {parent: _currentZoneFrame, zone: this}; + try { + return this._zoneDelegate.invoke(this, callback, applyThis, applyArgs, source); + } finally { + _currentZoneFrame = _currentZoneFrame.parent!; } + } - // tslint:disable-next-line:require-internal-with-underscore - static __load_patch(name: string, fn: _PatchFn, ignoreDuplicate = false): void { - if (patches.hasOwnProperty(name)) { - // `checkDuplicate` option is defined from global variable - // so it works for all modules. - // `ignoreDuplicate` can work for the specified module - if (!ignoreDuplicate && checkDuplicate) { - throw Error('Already loaded patch: ' + name); - } - } else if (!global['__Zone_disable_' + name]) { - const perfName = 'Zone:' + name; - mark(perfName); - patches[name] = fn(global, Zone, _api); - performanceMeasure(perfName, perfName); - } - } - - public get parent(): AmbientZone|null { - return this._parent; - } - - public get name(): string { - return this._name; - } - - - private _parent: Zone|null; - private _name: string; - private _properties: {[key: string]: any}; - private _zoneDelegate: _ZoneDelegate; - - constructor(parent: Zone|null, zoneSpec: ZoneSpec|null) { - this._parent = parent; - this._name = zoneSpec ? zoneSpec.name || 'unnamed' : ''; - this._properties = zoneSpec && zoneSpec.properties || {}; - this._zoneDelegate = - new _ZoneDelegate(this, this._parent && this._parent._zoneDelegate, zoneSpec); - } - - public get(key: string): any { - const zone: Zone = this.getZoneWith(key) as Zone; - if (zone) return zone._properties[key]; - } - - public getZoneWith(key: string): AmbientZone|null { - let current: Zone|null = this; - while (current) { - if (current._properties.hasOwnProperty(key)) { - return current; - } - current = current._parent; - } - return null; - } - - public fork(zoneSpec: ZoneSpec): AmbientZone { - if (!zoneSpec) throw new Error('ZoneSpec required!'); - return this._zoneDelegate.fork(this, zoneSpec); - } - - public wrap(callback: T, source: string): T { - if (typeof callback !== 'function') { - throw new Error('Expecting function got: ' + callback); - } - const _callback = this._zoneDelegate.intercept(this, callback, source); - const zone: Zone = this; - return function(this: unknown) { - return zone.runGuarded(_callback, this, arguments, source); - } as any as T; - } - - public run(callback: Function, applyThis?: any, applyArgs?: any[], source?: string): any; - public run( - callback: (...args: any[]) => T, applyThis?: any, applyArgs?: any[], source?: string): T { - _currentZoneFrame = {parent: _currentZoneFrame, zone: this}; + public runGuarded(callback: Function, applyThis?: any, applyArgs?: any[], source?: string): any; + public runGuarded( + callback: (...args: any[]) => T, applyThis: any = null, applyArgs?: any[], source?: string) { + _currentZoneFrame = {parent: _currentZoneFrame, zone: this}; + try { try { return this._zoneDelegate.invoke(this, callback, applyThis, applyArgs, source); - } finally { - _currentZoneFrame = _currentZoneFrame.parent!; + } catch (error) { + if (this._zoneDelegate.handleError(this, error)) { + throw error; + } } + } finally { + _currentZoneFrame = _currentZoneFrame.parent!; + } + } + + + runTask(task: Task, applyThis?: any, applyArgs?: any): any { + if (task.zone != this) { + throw new Error( + 'A task can only be run in the zone of creation! (Creation: ' + + (task.zone || NO_ZONE).name + '; Execution: ' + this.name + ')'); + } + // https://github.com/angular/zone.js/issues/778, sometimes eventTask + // will run in notScheduled(canceled) state, we should not try to + // run such kind of task but just return + + if (task.state === notScheduled && (task.type === eventTask || task.type === macroTask)) { + return; } - public runGuarded(callback: Function, applyThis?: any, applyArgs?: any[], source?: string): any; - public runGuarded( - callback: (...args: any[]) => T, applyThis: any = null, applyArgs?: any[], - source?: string) { - _currentZoneFrame = {parent: _currentZoneFrame, zone: this}; + const reEntryGuard = task.state != running; + reEntryGuard && (task as ZoneTask)._transitionTo(running, scheduled); + task.runCount++; + const previousTask = _currentTask; + _currentTask = task; + _currentZoneFrame = {parent: _currentZoneFrame, zone: this}; + try { + if (task.type == macroTask && task.data && !task.data.isPeriodic) { + task.cancelFn = undefined; + } try { - try { - return this._zoneDelegate.invoke(this, callback, applyThis, applyArgs, source); - } catch (error) { - if (this._zoneDelegate.handleError(this, error)) { - throw error; - } - } - } finally { - _currentZoneFrame = _currentZoneFrame.parent!; - } - } - - - runTask(task: Task, applyThis?: any, applyArgs?: any): any { - if (task.zone != this) { - throw new Error( - 'A task can only be run in the zone of creation! (Creation: ' + - (task.zone || NO_ZONE).name + '; Execution: ' + this.name + ')'); - } - // https://github.com/angular/zone.js/issues/778, sometimes eventTask - // will run in notScheduled(canceled) state, we should not try to - // run such kind of task but just return - - if (task.state === notScheduled && (task.type === eventTask || task.type === macroTask)) { - return; - } - - const reEntryGuard = task.state != running; - reEntryGuard && (task as ZoneTask)._transitionTo(running, scheduled); - task.runCount++; - const previousTask = _currentTask; - _currentTask = task; - _currentZoneFrame = {parent: _currentZoneFrame, zone: this}; - try { - if (task.type == macroTask && task.data && !task.data.isPeriodic) { - task.cancelFn = undefined; - } - try { - return this._zoneDelegate.invokeTask(this, task, applyThis, applyArgs); - } catch (error) { - if (this._zoneDelegate.handleError(this, error)) { - throw error; - } - } - } finally { - // if the task's state is notScheduled or unknown, then it has already been cancelled - // we should not reset the state to scheduled - if (task.state !== notScheduled && task.state !== unknown) { - if (task.type == eventTask || (task.data && task.data.isPeriodic)) { - reEntryGuard && (task as ZoneTask)._transitionTo(scheduled, running); - } else { - task.runCount = 0; - this._updateTaskCount(task as ZoneTask, -1); - reEntryGuard && - (task as ZoneTask)._transitionTo(notScheduled, running, notScheduled); - } - } - _currentZoneFrame = _currentZoneFrame.parent!; - _currentTask = previousTask; - } - } - - scheduleTask(task: T): T { - if (task.zone && task.zone !== this) { - // check if the task was rescheduled, the newZone - // should not be the children of the original zone - let newZone: any = this; - while (newZone) { - if (newZone === task.zone) { - throw Error(`can not reschedule task to ${ - this.name} which is descendants of the original zone ${task.zone.name}`); - } - newZone = newZone.parent; + return this._zoneDelegate.invokeTask(this, task, applyThis, applyArgs); + } catch (error) { + if (this._zoneDelegate.handleError(this, error)) { + throw error; } } - (task as any as ZoneTask)._transitionTo(scheduling, notScheduled); - const zoneDelegates: _ZoneDelegate[] = []; - (task as any as ZoneTask)._zoneDelegates = zoneDelegates; - (task as any as ZoneTask)._zone = this; - try { - task = this._zoneDelegate.scheduleTask(this, task) as T; - } catch (err) { - // should set task's state to unknown when scheduleTask throw error - // because the err may from reschedule, so the fromState maybe notScheduled - (task as any as ZoneTask)._transitionTo(unknown, scheduling, notScheduled); - // TODO: @JiaLiPassion, should we check the result from handleError? - this._zoneDelegate.handleError(this, err); - throw err; + } finally { + // if the task's state is notScheduled or unknown, then it has already been cancelled + // we should not reset the state to scheduled + if (task.state !== notScheduled && task.state !== unknown) { + if (task.type == eventTask || (task.data && task.data.isPeriodic)) { + reEntryGuard && (task as ZoneTask)._transitionTo(scheduled, running); + } else { + task.runCount = 0; + this._updateTaskCount(task as ZoneTask, -1); + reEntryGuard && + (task as ZoneTask)._transitionTo(notScheduled, running, notScheduled); + } } - if ((task as any as ZoneTask)._zoneDelegates === zoneDelegates) { - // we have to check because internally the delegate can reschedule the task. - this._updateTaskCount(task as any as ZoneTask, 1); + _currentZoneFrame = _currentZoneFrame.parent!; + _currentTask = previousTask; + } + } + + scheduleTask(task: T): T { + if (task.zone && task.zone !== this) { + // check if the task was rescheduled, the newZone + // should not be the children of the original zone + let newZone: any = this; + while (newZone) { + if (newZone === task.zone) { + throw Error(`can not reschedule task to ${ + this.name} which is descendants of the original zone ${task.zone.name}`); + } + newZone = newZone.parent; } - if ((task as any as ZoneTask).state == scheduling) { - (task as any as ZoneTask)._transitionTo(scheduled, scheduling); - } - return task; + } + (task as any as ZoneTask)._transitionTo(scheduling, notScheduled); + const zoneDelegates: _ZoneDelegate[] = []; + (task as any as ZoneTask)._zoneDelegates = zoneDelegates; + (task as any as ZoneTask)._zone = this; + try { + task = this._zoneDelegate.scheduleTask(this, task) as T; + } catch (err) { + // should set task's state to unknown when scheduleTask throw error + // because the err may from reschedule, so the fromState maybe notScheduled + (task as any as ZoneTask)._transitionTo(unknown, scheduling, notScheduled); + // TODO: @JiaLiPassion, should we check the result from handleError? + this._zoneDelegate.handleError(this, err); + throw err; + } + if ((task as any as ZoneTask)._zoneDelegates === zoneDelegates) { + // we have to check because internally the delegate can reschedule the task. + this._updateTaskCount(task as any as ZoneTask, 1); + } + if ((task as any as ZoneTask).state == scheduling) { + (task as any as ZoneTask)._transitionTo(scheduled, scheduling); + } + return task; + } + + scheduleMicroTask( + source: string, callback: Function, data?: TaskData, + customSchedule?: (task: Task) => void): MicroTask { + return this.scheduleTask( + new ZoneTask(microTask, source, callback, data, customSchedule, undefined)); + } + + scheduleMacroTask( + source: string, callback: Function, data?: TaskData, customSchedule?: (task: Task) => void, + customCancel?: (task: Task) => void): MacroTask { + return this.scheduleTask( + new ZoneTask(macroTask, source, callback, data, customSchedule, customCancel)); + } + + scheduleEventTask( + source: string, callback: Function, data?: TaskData, customSchedule?: (task: Task) => void, + customCancel?: (task: Task) => void): EventTask { + return this.scheduleTask( + new ZoneTask(eventTask, source, callback, data, customSchedule, customCancel)); + } + + cancelTask(task: Task): any { + if (task.zone != this) + throw new Error( + 'A task can only be cancelled in the zone of creation! (Creation: ' + + (task.zone || NO_ZONE).name + '; Execution: ' + this.name + ')'); + + if (task.state !== scheduled && task.state !== running) { + return; } - scheduleMicroTask( - source: string, callback: Function, data?: TaskData, - customSchedule?: (task: Task) => void): MicroTask { - return this.scheduleTask( - new ZoneTask(microTask, source, callback, data, customSchedule, undefined)); + (task as ZoneTask)._transitionTo(canceling, scheduled, running); + try { + this._zoneDelegate.cancelTask(this, task); + } catch (err) { + // if error occurs when cancelTask, transit the state to unknown + (task as ZoneTask)._transitionTo(unknown, canceling); + this._zoneDelegate.handleError(this, err); + throw err; } + this._updateTaskCount(task as ZoneTask, -1); + (task as ZoneTask)._transitionTo(notScheduled, canceling); + task.runCount = 0; + return task; + } - scheduleMacroTask( - source: string, callback: Function, data?: TaskData, customSchedule?: (task: Task) => void, - customCancel?: (task: Task) => void): MacroTask { - return this.scheduleTask( - new ZoneTask(macroTask, source, callback, data, customSchedule, customCancel)); + private _updateTaskCount(task: ZoneTask, count: number) { + const zoneDelegates = task._zoneDelegates!; + if (count == -1) { + task._zoneDelegates = null; } - - scheduleEventTask( - source: string, callback: Function, data?: TaskData, customSchedule?: (task: Task) => void, - customCancel?: (task: Task) => void): EventTask { - return this.scheduleTask( - new ZoneTask(eventTask, source, callback, data, customSchedule, customCancel)); + for (let i = 0; i < zoneDelegates.length; i++) { + zoneDelegates[i]._updateTaskCount(task.type, count); } + } +} - cancelTask(task: Task): any { - if (task.zone != this) - throw new Error( - 'A task can only be cancelled in the zone of creation! (Creation: ' + - (task.zone || NO_ZONE).name + '; Execution: ' + this.name + ')'); +const DELEGATE_ZS: ZoneSpec = { + name: '', + onHasTask: + (delegate: ZoneDelegate, _: AmbientZone, target: AmbientZone, hasTaskState: HasTaskState): + void => delegate.hasTask(target, hasTaskState), + onScheduleTask: (delegate: ZoneDelegate, _: AmbientZone, target: AmbientZone, task: Task): Task => + delegate.scheduleTask(target, task), + onInvokeTask: + (delegate: ZoneDelegate, _: AmbientZone, target: AmbientZone, task: Task, applyThis: any, + applyArgs: any): any => delegate.invokeTask(target, task, applyThis, applyArgs), + onCancelTask: (delegate: ZoneDelegate, _: AmbientZone, target: AmbientZone, task: Task): any => + delegate.cancelTask(target, task) +}; - if (task.state !== scheduled && task.state !== running) { - return; +class _ZoneDelegate implements ZoneDelegate { + public zone: Zone; + + private _taskCounts: + {microTask: number, + macroTask: number, + eventTask: number} = {'microTask': 0, 'macroTask': 0, 'eventTask': 0}; + + private _parentDelegate: _ZoneDelegate|null; + + private _forkDlgt: _ZoneDelegate|null; + private _forkZS: ZoneSpec|null; + private _forkCurrZone: Zone|null; + + private _interceptDlgt: _ZoneDelegate|null; + private _interceptZS: ZoneSpec|null; + private _interceptCurrZone: Zone|null; + + private _invokeDlgt: _ZoneDelegate|null; + private _invokeZS: ZoneSpec|null; + private _invokeCurrZone: Zone|null; + + private _handleErrorDlgt: _ZoneDelegate|null; + private _handleErrorZS: ZoneSpec|null; + private _handleErrorCurrZone: Zone|null; + + private _scheduleTaskDlgt: _ZoneDelegate|null; + private _scheduleTaskZS: ZoneSpec|null; + private _scheduleTaskCurrZone: Zone|null; + + private _invokeTaskDlgt: _ZoneDelegate|null; + private _invokeTaskZS: ZoneSpec|null; + private _invokeTaskCurrZone: Zone|null; + + private _cancelTaskDlgt: _ZoneDelegate|null; + private _cancelTaskZS: ZoneSpec|null; + private _cancelTaskCurrZone: Zone|null; + + private _hasTaskDlgt: _ZoneDelegate|null; + private _hasTaskDlgtOwner: _ZoneDelegate|null; + private _hasTaskZS: ZoneSpec|null; + private _hasTaskCurrZone: Zone|null; + + constructor(zone: Zone, parentDelegate: _ZoneDelegate|null, zoneSpec: ZoneSpec|null) { + this.zone = zone; + this._parentDelegate = parentDelegate; + + this._forkZS = zoneSpec && (zoneSpec && zoneSpec.onFork ? zoneSpec : parentDelegate!._forkZS); + this._forkDlgt = zoneSpec && (zoneSpec.onFork ? parentDelegate : parentDelegate!._forkDlgt); + this._forkCurrZone = zoneSpec && (zoneSpec.onFork ? this.zone : parentDelegate!._forkCurrZone); + + this._interceptZS = + zoneSpec && (zoneSpec.onIntercept ? zoneSpec : parentDelegate!._interceptZS); + this._interceptDlgt = + zoneSpec && (zoneSpec.onIntercept ? parentDelegate : parentDelegate!._interceptDlgt); + this._interceptCurrZone = + zoneSpec && (zoneSpec.onIntercept ? this.zone : parentDelegate!._interceptCurrZone); + + this._invokeZS = zoneSpec && (zoneSpec.onInvoke ? zoneSpec : parentDelegate!._invokeZS); + this._invokeDlgt = + zoneSpec && (zoneSpec.onInvoke ? parentDelegate! : parentDelegate!._invokeDlgt); + this._invokeCurrZone = + zoneSpec && (zoneSpec.onInvoke ? this.zone : parentDelegate!._invokeCurrZone); + + this._handleErrorZS = + zoneSpec && (zoneSpec.onHandleError ? zoneSpec : parentDelegate!._handleErrorZS); + this._handleErrorDlgt = + zoneSpec && (zoneSpec.onHandleError ? parentDelegate! : parentDelegate!._handleErrorDlgt); + this._handleErrorCurrZone = + zoneSpec && (zoneSpec.onHandleError ? this.zone : parentDelegate!._handleErrorCurrZone); + + this._scheduleTaskZS = + zoneSpec && (zoneSpec.onScheduleTask ? zoneSpec : parentDelegate!._scheduleTaskZS); + this._scheduleTaskDlgt = + zoneSpec && (zoneSpec.onScheduleTask ? parentDelegate! : parentDelegate!._scheduleTaskDlgt); + this._scheduleTaskCurrZone = + zoneSpec && (zoneSpec.onScheduleTask ? this.zone : parentDelegate!._scheduleTaskCurrZone); + + this._invokeTaskZS = + zoneSpec && (zoneSpec.onInvokeTask ? zoneSpec : parentDelegate!._invokeTaskZS); + this._invokeTaskDlgt = + zoneSpec && (zoneSpec.onInvokeTask ? parentDelegate! : parentDelegate!._invokeTaskDlgt); + this._invokeTaskCurrZone = + zoneSpec && (zoneSpec.onInvokeTask ? this.zone : parentDelegate!._invokeTaskCurrZone); + + this._cancelTaskZS = + zoneSpec && (zoneSpec.onCancelTask ? zoneSpec : parentDelegate!._cancelTaskZS); + this._cancelTaskDlgt = + zoneSpec && (zoneSpec.onCancelTask ? parentDelegate! : parentDelegate!._cancelTaskDlgt); + this._cancelTaskCurrZone = + zoneSpec && (zoneSpec.onCancelTask ? this.zone : parentDelegate!._cancelTaskCurrZone); + + this._hasTaskZS = null; + this._hasTaskDlgt = null; + this._hasTaskDlgtOwner = null; + this._hasTaskCurrZone = null; + + const zoneSpecHasTask = zoneSpec && zoneSpec.onHasTask; + const parentHasTask = parentDelegate && parentDelegate._hasTaskZS; + if (zoneSpecHasTask || parentHasTask) { + // If we need to report hasTask, than this ZS needs to do ref counting on tasks. In such + // a case all task related interceptors must go through this ZD. We can't short circuit it. + this._hasTaskZS = zoneSpecHasTask ? zoneSpec : DELEGATE_ZS; + this._hasTaskDlgt = parentDelegate; + this._hasTaskDlgtOwner = this; + this._hasTaskCurrZone = zone; + if (!zoneSpec!.onScheduleTask) { + this._scheduleTaskZS = DELEGATE_ZS; + this._scheduleTaskDlgt = parentDelegate!; + this._scheduleTaskCurrZone = this.zone; } - - (task as ZoneTask)._transitionTo(canceling, scheduled, running); - try { - this._zoneDelegate.cancelTask(this, task); - } catch (err) { - // if error occurs when cancelTask, transit the state to unknown - (task as ZoneTask)._transitionTo(unknown, canceling); - this._zoneDelegate.handleError(this, err); - throw err; + if (!zoneSpec!.onInvokeTask) { + this._invokeTaskZS = DELEGATE_ZS; + this._invokeTaskDlgt = parentDelegate!; + this._invokeTaskCurrZone = this.zone; } - this._updateTaskCount(task as ZoneTask, -1); - (task as ZoneTask)._transitionTo(notScheduled, canceling); - task.runCount = 0; - return task; - } - - private _updateTaskCount(task: ZoneTask, count: number) { - const zoneDelegates = task._zoneDelegates!; - if (count == -1) { - task._zoneDelegates = null; - } - for (let i = 0; i < zoneDelegates.length; i++) { - zoneDelegates[i]._updateTaskCount(task.type, count); + if (!zoneSpec!.onCancelTask) { + this._cancelTaskZS = DELEGATE_ZS; + this._cancelTaskDlgt = parentDelegate!; + this._cancelTaskCurrZone = this.zone; } } } - const DELEGATE_ZS: ZoneSpec = { - name: '', - onHasTask: - (delegate: ZoneDelegate, _: AmbientZone, target: AmbientZone, hasTaskState: HasTaskState): - void => delegate.hasTask(target, hasTaskState), - onScheduleTask: (delegate: ZoneDelegate, _: AmbientZone, target: AmbientZone, task: Task): - Task => delegate.scheduleTask(target, task), - onInvokeTask: - (delegate: ZoneDelegate, _: AmbientZone, target: AmbientZone, task: Task, applyThis: any, - applyArgs: any): any => delegate.invokeTask(target, task, applyThis, applyArgs), - onCancelTask: (delegate: ZoneDelegate, _: AmbientZone, target: AmbientZone, task: Task): any => - delegate.cancelTask(target, task) - }; + fork(targetZone: Zone, zoneSpec: ZoneSpec): AmbientZone { + return this._forkZS ? this._forkZS.onFork!(this._forkDlgt!, this.zone, targetZone, zoneSpec) : + new Zone(targetZone, zoneSpec); + } - class _ZoneDelegate implements ZoneDelegate { - public zone: Zone; + intercept(targetZone: Zone, callback: Function, source: string): Function { + return this._interceptZS ? + this._interceptZS.onIntercept! + (this._interceptDlgt!, this._interceptCurrZone!, targetZone, callback, source) : + callback; + } - private _taskCounts: - {microTask: number, - macroTask: number, - eventTask: number} = {'microTask': 0, 'macroTask': 0, 'eventTask': 0}; + invoke(targetZone: Zone, callback: Function, applyThis: any, applyArgs?: any[], source?: string): + any { + return this._invokeZS ? this._invokeZS.onInvoke! + (this._invokeDlgt!, this._invokeCurrZone!, targetZone, callback, + applyThis, applyArgs, source) : + callback.apply(applyThis, applyArgs); + } - private _parentDelegate: _ZoneDelegate|null; + handleError(targetZone: Zone, error: any): boolean { + return this._handleErrorZS ? + this._handleErrorZS.onHandleError! + (this._handleErrorDlgt!, this._handleErrorCurrZone!, targetZone, error) : + true; + } - private _forkDlgt: _ZoneDelegate|null; - private _forkZS: ZoneSpec|null; - private _forkCurrZone: Zone|null; - - private _interceptDlgt: _ZoneDelegate|null; - private _interceptZS: ZoneSpec|null; - private _interceptCurrZone: Zone|null; - - private _invokeDlgt: _ZoneDelegate|null; - private _invokeZS: ZoneSpec|null; - private _invokeCurrZone: Zone|null; - - private _handleErrorDlgt: _ZoneDelegate|null; - private _handleErrorZS: ZoneSpec|null; - private _handleErrorCurrZone: Zone|null; - - private _scheduleTaskDlgt: _ZoneDelegate|null; - private _scheduleTaskZS: ZoneSpec|null; - private _scheduleTaskCurrZone: Zone|null; - - private _invokeTaskDlgt: _ZoneDelegate|null; - private _invokeTaskZS: ZoneSpec|null; - private _invokeTaskCurrZone: Zone|null; - - private _cancelTaskDlgt: _ZoneDelegate|null; - private _cancelTaskZS: ZoneSpec|null; - private _cancelTaskCurrZone: Zone|null; - - private _hasTaskDlgt: _ZoneDelegate|null; - private _hasTaskDlgtOwner: _ZoneDelegate|null; - private _hasTaskZS: ZoneSpec|null; - private _hasTaskCurrZone: Zone|null; - - constructor(zone: Zone, parentDelegate: _ZoneDelegate|null, zoneSpec: ZoneSpec|null) { - this.zone = zone; - this._parentDelegate = parentDelegate; - - this._forkZS = zoneSpec && (zoneSpec && zoneSpec.onFork ? zoneSpec : parentDelegate!._forkZS); - this._forkDlgt = zoneSpec && (zoneSpec.onFork ? parentDelegate : parentDelegate!._forkDlgt); - this._forkCurrZone = - zoneSpec && (zoneSpec.onFork ? this.zone : parentDelegate!._forkCurrZone); - - this._interceptZS = - zoneSpec && (zoneSpec.onIntercept ? zoneSpec : parentDelegate!._interceptZS); - this._interceptDlgt = - zoneSpec && (zoneSpec.onIntercept ? parentDelegate : parentDelegate!._interceptDlgt); - this._interceptCurrZone = - zoneSpec && (zoneSpec.onIntercept ? this.zone : parentDelegate!._interceptCurrZone); - - this._invokeZS = zoneSpec && (zoneSpec.onInvoke ? zoneSpec : parentDelegate!._invokeZS); - this._invokeDlgt = - zoneSpec && (zoneSpec.onInvoke ? parentDelegate! : parentDelegate!._invokeDlgt); - this._invokeCurrZone = - zoneSpec && (zoneSpec.onInvoke ? this.zone : parentDelegate!._invokeCurrZone); - - this._handleErrorZS = - zoneSpec && (zoneSpec.onHandleError ? zoneSpec : parentDelegate!._handleErrorZS); - this._handleErrorDlgt = - zoneSpec && (zoneSpec.onHandleError ? parentDelegate! : parentDelegate!._handleErrorDlgt); - this._handleErrorCurrZone = - zoneSpec && (zoneSpec.onHandleError ? this.zone : parentDelegate!._handleErrorCurrZone); - - this._scheduleTaskZS = - zoneSpec && (zoneSpec.onScheduleTask ? zoneSpec : parentDelegate!._scheduleTaskZS); - this._scheduleTaskDlgt = zoneSpec && - (zoneSpec.onScheduleTask ? parentDelegate! : parentDelegate!._scheduleTaskDlgt); - this._scheduleTaskCurrZone = - zoneSpec && (zoneSpec.onScheduleTask ? this.zone : parentDelegate!._scheduleTaskCurrZone); - - this._invokeTaskZS = - zoneSpec && (zoneSpec.onInvokeTask ? zoneSpec : parentDelegate!._invokeTaskZS); - this._invokeTaskDlgt = - zoneSpec && (zoneSpec.onInvokeTask ? parentDelegate! : parentDelegate!._invokeTaskDlgt); - this._invokeTaskCurrZone = - zoneSpec && (zoneSpec.onInvokeTask ? this.zone : parentDelegate!._invokeTaskCurrZone); - - this._cancelTaskZS = - zoneSpec && (zoneSpec.onCancelTask ? zoneSpec : parentDelegate!._cancelTaskZS); - this._cancelTaskDlgt = - zoneSpec && (zoneSpec.onCancelTask ? parentDelegate! : parentDelegate!._cancelTaskDlgt); - this._cancelTaskCurrZone = - zoneSpec && (zoneSpec.onCancelTask ? this.zone : parentDelegate!._cancelTaskCurrZone); - - this._hasTaskZS = null; - this._hasTaskDlgt = null; - this._hasTaskDlgtOwner = null; - this._hasTaskCurrZone = null; - - const zoneSpecHasTask = zoneSpec && zoneSpec.onHasTask; - const parentHasTask = parentDelegate && parentDelegate._hasTaskZS; - if (zoneSpecHasTask || parentHasTask) { - // If we need to report hasTask, than this ZS needs to do ref counting on tasks. In such - // a case all task related interceptors must go through this ZD. We can't short circuit it. - this._hasTaskZS = zoneSpecHasTask ? zoneSpec : DELEGATE_ZS; - this._hasTaskDlgt = parentDelegate; - this._hasTaskDlgtOwner = this; - this._hasTaskCurrZone = zone; - if (!zoneSpec!.onScheduleTask) { - this._scheduleTaskZS = DELEGATE_ZS; - this._scheduleTaskDlgt = parentDelegate!; - this._scheduleTaskCurrZone = this.zone; - } - if (!zoneSpec!.onInvokeTask) { - this._invokeTaskZS = DELEGATE_ZS; - this._invokeTaskDlgt = parentDelegate!; - this._invokeTaskCurrZone = this.zone; - } - if (!zoneSpec!.onCancelTask) { - this._cancelTaskZS = DELEGATE_ZS; - this._cancelTaskDlgt = parentDelegate!; - this._cancelTaskCurrZone = this.zone; - } + scheduleTask(targetZone: Zone, task: Task): Task { + let returnTask: ZoneTask = task as ZoneTask; + if (this._scheduleTaskZS) { + if (this._hasTaskZS) { + returnTask._zoneDelegates!.push(this._hasTaskDlgtOwner!); } - } - - fork(targetZone: Zone, zoneSpec: ZoneSpec): AmbientZone { - return this._forkZS ? this._forkZS.onFork!(this._forkDlgt!, this.zone, targetZone, zoneSpec) : - new Zone(targetZone, zoneSpec); - } - - intercept(targetZone: Zone, callback: Function, source: string): Function { - return this._interceptZS ? - this._interceptZS.onIntercept! - (this._interceptDlgt!, this._interceptCurrZone!, targetZone, callback, source) : - callback; - } - - invoke( - targetZone: Zone, callback: Function, applyThis: any, applyArgs?: any[], - source?: string): any { - return this._invokeZS ? this._invokeZS.onInvoke! - (this._invokeDlgt!, this._invokeCurrZone!, targetZone, callback, - applyThis, applyArgs, source) : - callback.apply(applyThis, applyArgs); - } - - handleError(targetZone: Zone, error: any): boolean { - return this._handleErrorZS ? - this._handleErrorZS.onHandleError! - (this._handleErrorDlgt!, this._handleErrorCurrZone!, targetZone, error) : - true; - } - - scheduleTask(targetZone: Zone, task: Task): Task { - let returnTask: ZoneTask = task as ZoneTask; - if (this._scheduleTaskZS) { - if (this._hasTaskZS) { - returnTask._zoneDelegates!.push(this._hasTaskDlgtOwner!); - } - // clang-format off + // clang-format off returnTask = this._scheduleTaskZS.onScheduleTask !( this._scheduleTaskDlgt !, this._scheduleTaskCurrZone !, targetZone, task) as ZoneTask; - // clang-format on - if (!returnTask) returnTask = task as ZoneTask; + // clang-format on + if (!returnTask) returnTask = task as ZoneTask; + } else { + if (task.scheduleFn) { + task.scheduleFn(task); + } else if (task.type == microTask) { + scheduleMicroTask(task); } else { - if (task.scheduleFn) { - task.scheduleFn(task); - } else if (task.type == microTask) { - scheduleMicroTask(task); - } else { - throw new Error('Task is missing scheduleFn.'); - } - } - return returnTask; - } - - invokeTask(targetZone: Zone, task: Task, applyThis: any, applyArgs?: any[]): any { - return this._invokeTaskZS ? this._invokeTaskZS.onInvokeTask! - (this._invokeTaskDlgt!, this._invokeTaskCurrZone!, targetZone, - task, applyThis, applyArgs) : - task.callback.apply(applyThis, applyArgs); - } - - cancelTask(targetZone: Zone, task: Task): any { - let value: any; - if (this._cancelTaskZS) { - value = this._cancelTaskZS.onCancelTask! - (this._cancelTaskDlgt!, this._cancelTaskCurrZone!, targetZone, task); - } else { - if (!task.cancelFn) { - throw Error('Task is not cancelable'); - } - value = task.cancelFn(task); - } - return value; - } - - hasTask(targetZone: Zone, isEmpty: HasTaskState) { - // hasTask should not throw error so other ZoneDelegate - // can still trigger hasTask callback - try { - this._hasTaskZS && - this._hasTaskZS.onHasTask! - (this._hasTaskDlgt!, this._hasTaskCurrZone!, targetZone, isEmpty); - } catch (err) { - this.handleError(targetZone, err); + throw new Error('Task is missing scheduleFn.'); } } + return returnTask; + } - // tslint:disable-next-line:require-internal-with-underscore - _updateTaskCount(type: TaskType, count: number) { - const counts = this._taskCounts; - const prev = counts[type]; - const next = counts[type] = prev + count; - if (next < 0) { - throw new Error('More tasks executed then were scheduled.'); - } - if (prev == 0 || next == 0) { - const isEmpty: HasTaskState = { - microTask: counts['microTask'] > 0, - macroTask: counts['macroTask'] > 0, - eventTask: counts['eventTask'] > 0, - change: type - }; - this.hasTask(this.zone, isEmpty); + invokeTask(targetZone: Zone, task: Task, applyThis: any, applyArgs?: any[]): any { + return this._invokeTaskZS ? + this._invokeTaskZS.onInvokeTask! + (this._invokeTaskDlgt!, this._invokeTaskCurrZone!, targetZone, task, applyThis, applyArgs) : + task.callback.apply(applyThis, applyArgs); + } + + cancelTask(targetZone: Zone, task: Task): any { + let value: any; + if (this._cancelTaskZS) { + value = this._cancelTaskZS.onCancelTask! + (this._cancelTaskDlgt!, this._cancelTaskCurrZone!, targetZone, task); + } else { + if (!task.cancelFn) { + throw Error('Task is not cancelable'); } + value = task.cancelFn(task); + } + return value; + } + + hasTask(targetZone: Zone, isEmpty: HasTaskState) { + // hasTask should not throw error so other ZoneDelegate + // can still trigger hasTask callback + try { + this._hasTaskZS && + this._hasTaskZS.onHasTask! + (this._hasTaskDlgt!, this._hasTaskCurrZone!, targetZone, isEmpty); + } catch (err) { + this.handleError(targetZone, err); } } - class ZoneTask implements Task { - public type: T; - public source: string; - public invoke: Function; - public callback: Function; - public data: TaskData|undefined; - public scheduleFn: ((task: Task) => void)|undefined; - public cancelFn: ((task: Task) => void)|undefined; - // tslint:disable-next-line:require-internal-with-underscore - _zone: Zone|null = null; - public runCount: number = 0; - // tslint:disable-next-line:require-internal-with-underscore - _zoneDelegates: _ZoneDelegate[]|null = null; - // tslint:disable-next-line:require-internal-with-underscore - _state: TaskState = 'notScheduled'; - - constructor( - type: T, source: string, callback: Function, options: TaskData|undefined, - scheduleFn: ((task: Task) => void)|undefined, cancelFn: ((task: Task) => void)|undefined) { - this.type = type; - this.source = source; - this.data = options; - this.scheduleFn = scheduleFn; - this.cancelFn = cancelFn; - if (!callback) { - throw new Error('callback is not defined'); - } - this.callback = callback; - const self = this; - // TODO: @JiaLiPassion options should have interface - if (type === eventTask && options && (options as any).useG) { - this.invoke = ZoneTask.invokeTask; - } else { - this.invoke = function() { - return ZoneTask.invokeTask.call(global, self, this, arguments); - }; - } + // tslint:disable-next-line:require-internal-with-underscore + _updateTaskCount(type: TaskType, count: number) { + const counts = this._taskCounts; + const prev = counts[type]; + const next = counts[type] = prev + count; + if (next < 0) { + throw new Error('More tasks executed then were scheduled.'); } - - static invokeTask(task: any, target: any, args: any): any { - if (!task) { - task = this; - } - _numberOfNestedTaskFrames++; - try { - task.runCount++; - return task.zone.runTask(task, target, args); - } finally { - if (_numberOfNestedTaskFrames == 1) { - drainMicroTaskQueue(); - } - _numberOfNestedTaskFrames--; - } + if (prev == 0 || next == 0) { + const isEmpty: HasTaskState = { + microTask: counts['microTask'] > 0, + macroTask: counts['macroTask'] > 0, + eventTask: counts['eventTask'] > 0, + change: type + }; + this.hasTask(this.zone, isEmpty); } + } +} - get zone(): Zone { - return this._zone!; +class ZoneTask implements Task { + public type: T; + public source: string; + public invoke: Function; + public callback: Function; + public data: TaskData|undefined; + public scheduleFn: ((task: Task) => void)|undefined; + public cancelFn: ((task: Task) => void)|undefined; + // tslint:disable-next-line:require-internal-with-underscore + _zone: Zone|null = null; + public runCount: number = 0; + // tslint:disable-next-line:require-internal-with-underscore + _zoneDelegates: _ZoneDelegate[]|null = null; + // tslint:disable-next-line:require-internal-with-underscore + _state: TaskState = 'notScheduled'; + + constructor( + type: T, source: string, callback: Function, options: TaskData|undefined, + scheduleFn: ((task: Task) => void)|undefined, cancelFn: ((task: Task) => void)|undefined) { + this.type = type; + this.source = source; + this.data = options; + this.scheduleFn = scheduleFn; + this.cancelFn = cancelFn; + if (!callback) { + throw new Error('callback is not defined'); } - - get state(): TaskState { - return this._state; - } - - public cancelScheduleRequest() { - this._transitionTo(notScheduled, scheduling); - } - - // tslint:disable-next-line:require-internal-with-underscore - _transitionTo(toState: TaskState, fromState1: TaskState, fromState2?: TaskState) { - if (this._state === fromState1 || this._state === fromState2) { - this._state = toState; - if (toState == notScheduled) { - this._zoneDelegates = null; - } - } else { - throw new Error(`${this.type} '${this.source}': can not transition to '${ - toState}', expecting state '${fromState1}'${ - fromState2 ? ' or \'' + fromState2 + '\'' : ''}, was '${this._state}'.`); - } - } - - public toString() { - if (this.data && typeof this.data.handleId !== 'undefined') { - return this.data.handleId.toString(); - } else { - return Object.prototype.toString.call(this); - } - } - - // add toJSON method to prevent cyclic error when - // call JSON.stringify(zoneTask) - public toJSON() { - return { - type: this.type, - state: this.state, - source: this.source, - zone: this.zone.name, - runCount: this.runCount + this.callback = callback; + const self = this; + // TODO: @JiaLiPassion options should have interface + if (type === eventTask && options && (options as any).useG) { + this.invoke = ZoneTask.invokeTask; + } else { + this.invoke = function() { + return ZoneTask.invokeTask.call(global, self, this, arguments); }; } } - - ////////////////////////////////////////////////////// - ////////////////////////////////////////////////////// - /// MICROTASK QUEUE - ////////////////////////////////////////////////////// - ////////////////////////////////////////////////////// - const symbolSetTimeout = __symbol__('setTimeout'); - const symbolPromise = __symbol__('Promise'); - const symbolThen = __symbol__('then'); - let _microTaskQueue: Task[] = []; - let _isDrainingMicrotaskQueue: boolean = false; - let nativeMicroTaskQueuePromise: any; - - function nativeScheduleMicroTask(func: Function) { - if (!nativeMicroTaskQueuePromise) { - if (global[symbolPromise]) { - nativeMicroTaskQueuePromise = global[symbolPromise].resolve(0); - } + static invokeTask(task: any, target: any, args: any): any { + if (!task) { + task = this; } - if (nativeMicroTaskQueuePromise) { - let nativeThen = nativeMicroTaskQueuePromise[symbolThen]; - if (!nativeThen) { - // native Promise is not patchable, we need to use `then` directly - // issue 1078 - nativeThen = nativeMicroTaskQueuePromise['then']; + _numberOfNestedTaskFrames++; + try { + task.runCount++; + return task.zone.runTask(task, target, args); + } finally { + if (_numberOfNestedTaskFrames == 1) { + drainMicroTaskQueue(); + } + _numberOfNestedTaskFrames--; + } + } + + get zone(): Zone { + return this._zone!; + } + + get state(): TaskState { + return this._state; + } + + public cancelScheduleRequest() { + this._transitionTo(notScheduled, scheduling); + } + + // tslint:disable-next-line:require-internal-with-underscore + _transitionTo(toState: TaskState, fromState1: TaskState, fromState2?: TaskState) { + if (this._state === fromState1 || this._state === fromState2) { + this._state = toState; + if (toState == notScheduled) { + this._zoneDelegates = null; } - nativeThen.call(nativeMicroTaskQueuePromise, func); } else { - global[symbolSetTimeout](func, 0); + throw new Error(`${this.type} '${this.source}': can not transition to '${ + toState}', expecting state '${fromState1}'${ + fromState2 ? ' or \'' + fromState2 + '\'' : ''}, was '${this._state}'.`); } } - function scheduleMicroTask(task?: MicroTask) { - // if we are not running in any task, and there has not been anything scheduled - // we must bootstrap the initial task creation by manually scheduling the drain - if (_numberOfNestedTaskFrames === 0 && _microTaskQueue.length === 0) { - // We are not running in Task, so we need to kickstart the microtask queue. - nativeScheduleMicroTask(drainMicroTaskQueue); + public toString() { + if (this.data && typeof this.data.handleId !== 'undefined') { + return this.data.handleId.toString(); + } else { + return Object.prototype.toString.call(this); } - task && _microTaskQueue.push(task); } - function drainMicroTaskQueue() { - if (!_isDrainingMicrotaskQueue) { - _isDrainingMicrotaskQueue = true; - while (_microTaskQueue.length) { - const queue = _microTaskQueue; - _microTaskQueue = []; - for (let i = 0; i < queue.length; i++) { - const task = queue[i]; - try { - task.zone.runTask(task, null, null); - } catch (error) { - _api.onUnhandledError(error as Error); - } + // add toJSON method to prevent cyclic error when + // call JSON.stringify(zoneTask) + public toJSON() { + return { + type: this.type, + state: this.state, + source: this.source, + zone: this.zone.name, + runCount: this.runCount + }; + } +} + + +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +/// MICROTASK QUEUE +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +const symbolSetTimeout = __symbol__('setTimeout'); +const symbolPromise = __symbol__('Promise'); +const symbolThen = __symbol__('then'); +let _microTaskQueue: Task[] = []; +let _isDrainingMicrotaskQueue: boolean = false; +let nativeMicroTaskQueuePromise: any; + +function nativeScheduleMicroTask(func: Function) { + if (!nativeMicroTaskQueuePromise) { + if (global[symbolPromise]) { + nativeMicroTaskQueuePromise = global[symbolPromise].resolve(0); + } + } + if (nativeMicroTaskQueuePromise) { + let nativeThen = nativeMicroTaskQueuePromise[symbolThen]; + if (!nativeThen) { + // native Promise is not patchable, we need to use `then` directly + // issue 1078 + nativeThen = nativeMicroTaskQueuePromise['then']; + } + nativeThen.call(nativeMicroTaskQueuePromise, func); + } else { + global[symbolSetTimeout](func, 0); + } +} + +function scheduleMicroTask(task?: MicroTask) { + // if we are not running in any task, and there has not been anything scheduled + // we must bootstrap the initial task creation by manually scheduling the drain + if (_numberOfNestedTaskFrames === 0 && _microTaskQueue.length === 0) { + // We are not running in Task, so we need to kickstart the microtask queue. + nativeScheduleMicroTask(drainMicroTaskQueue); + } + task && _microTaskQueue.push(task); +} + +function drainMicroTaskQueue() { + if (!_isDrainingMicrotaskQueue) { + _isDrainingMicrotaskQueue = true; + while (_microTaskQueue.length) { + const queue = _microTaskQueue; + _microTaskQueue = []; + for (let i = 0; i < queue.length; i++) { + const task = queue[i]; + try { + task.zone.runTask(task, null, null); + } catch (error) { + _api.onUnhandledError(error as Error); } } - _api.microtaskDrainDone(); - _isDrainingMicrotaskQueue = false; } + _api.microtaskDrainDone(); + _isDrainingMicrotaskQueue = false; } +} - ////////////////////////////////////////////////////// - ////////////////////////////////////////////////////// - /// BOOTSTRAP - ////////////////////////////////////////////////////// - ////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +/// BOOTSTRAP +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// - const NO_ZONE = {name: 'NO ZONE'}; - const notScheduled: 'notScheduled' = 'notScheduled', scheduling: 'scheduling' = 'scheduling', - scheduled: 'scheduled' = 'scheduled', running: 'running' = 'running', - canceling: 'canceling' = 'canceling', unknown: 'unknown' = 'unknown'; - const microTask: 'microTask' = 'microTask', macroTask: 'macroTask' = 'macroTask', - eventTask: 'eventTask' = 'eventTask'; +const NO_ZONE = { + name: 'NO ZONE' +}; +const notScheduled: 'notScheduled' = 'notScheduled', scheduling: 'scheduling' = 'scheduling', + scheduled: 'scheduled' = 'scheduled', running: 'running' = 'running', + canceling: 'canceling' = 'canceling', unknown: 'unknown' = 'unknown'; +const microTask: 'microTask' = 'microTask', macroTask: 'macroTask' = 'macroTask', + eventTask: 'eventTask' = 'eventTask'; - const patches: {[key: string]: any} = {}; - const _api: _ZonePrivate = { - symbol: __symbol__, - currentZoneFrame: () => _currentZoneFrame, - onUnhandledError: noop, - microtaskDrainDone: noop, - scheduleMicroTask: scheduleMicroTask, - showUncaughtError: () => !(Zone as any)[__symbol__('ignoreConsoleErrorUncaughtError')], - patchEventTarget: () => [], - patchOnProperties: noop, - patchMethod: () => noop, - bindArguments: () => [], - patchThen: () => noop, - patchMacroTask: () => noop, - patchEventPrototype: () => noop, - isIEOrEdge: () => false, - getGlobalObjects: () => undefined, - ObjectDefineProperty: () => noop, - ObjectGetOwnPropertyDescriptor: () => undefined, - ObjectCreate: () => undefined, - ArraySlice: () => [], - patchClass: () => noop, - wrapWithCurrentZone: () => noop, - filterProperties: () => [], - attachOriginToPatched: () => noop, - _redefineProperty: () => noop, - patchCallbacks: () => noop, - nativeScheduleMicroTask: nativeScheduleMicroTask - }; - let _currentZoneFrame: _ZoneFrame = {parent: null, zone: new Zone(null, null)}; - let _currentTask: Task|null = null; - let _numberOfNestedTaskFrames = 0; +const patches: {[key: string]: any} = {}; +const _api: _ZonePrivate = { + symbol: __symbol__, + currentZoneFrame: () => _currentZoneFrame, + onUnhandledError: noop, + microtaskDrainDone: noop, + scheduleMicroTask: scheduleMicroTask, + showUncaughtError: () => !(Zone as any)[__symbol__('ignoreConsoleErrorUncaughtError')], + patchEventTarget: () => [], + patchOnProperties: noop, + patchMethod: () => noop, + bindArguments: () => [], + patchThen: () => noop, + patchMacroTask: () => noop, + patchEventPrototype: () => noop, + isIEOrEdge: () => false, + getGlobalObjects: () => undefined, + ObjectDefineProperty: () => noop, + ObjectGetOwnPropertyDescriptor: () => undefined, + ObjectCreate: () => undefined, + ArraySlice: () => [], + patchClass: () => noop, + wrapWithCurrentZone: () => noop, + filterProperties: () => [], + attachOriginToPatched: () => noop, + _redefineProperty: () => noop, + patchCallbacks: () => noop, + nativeScheduleMicroTask: nativeScheduleMicroTask +}; +let _currentZoneFrame: _ZoneFrame = {parent: null, zone: new Zone(null, null)}; +let _currentTask: Task|null = null; +let _numberOfNestedTaskFrames = 0; - function noop() {} +function noop() {} - performanceMeasure('Zone', 'Zone'); - return global['Zone'] = Zone; +performanceMeasure('Zone', 'Zone'); +return global['Zone'] = Zone; })(globalThis); + +export {}; diff --git a/packages/zone.js/test/BUILD.bazel b/packages/zone.js/test/BUILD.bazel index 51b93cfe7b1..196c252fc6d 100644 --- a/packages/zone.js/test/BUILD.bazel +++ b/packages/zone.js/test/BUILD.bazel @@ -116,6 +116,7 @@ ts_library( deps = [ ":common_spec_env", "//packages/zone.js/lib", + "//packages/zone.js/lib:zone_d_ts", "@npm//bluebird", ], ) @@ -139,6 +140,7 @@ ts_library( deps = [ ":common_spec_env", "//packages/zone.js/lib", + "//packages/zone.js/lib:zone_d_ts", ], ) diff --git a/packages/zone.js/test/npm_package/npm_package.spec.ts b/packages/zone.js/test/npm_package/npm_package.spec.ts index ecf911d54f5..d4e5193b087 100644 --- a/packages/zone.js/test/npm_package/npm_package.spec.ts +++ b/packages/zone.js/test/npm_package/npm_package.spec.ts @@ -50,7 +50,8 @@ describe('Zone.js npm_package', () => { describe('check npm_package root folder', () => { describe('typescript support', () => { it('should have an zone.d.ts file', () => { - expect(shx.cat('zone.d.ts')).toContain('declare const'); + expect(shx.cat('zone.d.ts')).toContain('declare global {'); + expect(shx.cat('zone.d.ts')).toContain('const Zone'); expect(shx.cat('zone.d.ts')).toContain('interface EventTarget'); expect(shx.cat('zone.d.ts')).toContain('ZoneGlobalConfigurations'); });