| /** |
| * @license |
| * Copyright Google Inc. All Rights Reserved. |
| * |
| * Use of this source code is governed by an MIT-style license that can be |
| * found in the LICENSE file at https://angular.io/license |
| */ |
| (function (global, factory) { |
| typeof exports === 'object' && typeof module !== 'undefined' ? factory() : |
| typeof define === 'function' && define.amd ? define(factory) : |
| (factory()); |
| }(this, (function () { 'use strict'; |
| |
| /** |
| * @license |
| * Copyright Google Inc. All Rights Reserved. |
| * |
| * Use of this source code is governed by an MIT-style license that can be |
| * found in the LICENSE file at https://angular.io/license |
| */ |
| var ProxyZoneSpec = /** @class */ (function () { |
| function ProxyZoneSpec(defaultSpecDelegate) { |
| if (defaultSpecDelegate === void 0) { defaultSpecDelegate = null; } |
| this.defaultSpecDelegate = defaultSpecDelegate; |
| this.name = 'ProxyZone'; |
| this._delegateSpec = null; |
| this.properties = { 'ProxyZoneSpec': this }; |
| this.propertyKeys = null; |
| this.lastTaskState = null; |
| this.isNeedToTriggerHasTask = false; |
| this.tasks = []; |
| this.setDelegate(defaultSpecDelegate); |
| } |
| ProxyZoneSpec.get = function () { |
| return Zone.current.get('ProxyZoneSpec'); |
| }; |
| ProxyZoneSpec.isLoaded = function () { |
| return ProxyZoneSpec.get() instanceof ProxyZoneSpec; |
| }; |
| ProxyZoneSpec.assertPresent = function () { |
| if (!ProxyZoneSpec.isLoaded()) { |
| throw new Error("Expected to be running in 'ProxyZone', but it was not found."); |
| } |
| return ProxyZoneSpec.get(); |
| }; |
| ProxyZoneSpec.prototype.setDelegate = function (delegateSpec) { |
| var _this = this; |
| var isNewDelegate = this._delegateSpec !== delegateSpec; |
| this._delegateSpec = delegateSpec; |
| this.propertyKeys && this.propertyKeys.forEach(function (key) { return delete _this.properties[key]; }); |
| this.propertyKeys = null; |
| if (delegateSpec && delegateSpec.properties) { |
| this.propertyKeys = Object.keys(delegateSpec.properties); |
| this.propertyKeys.forEach(function (k) { return _this.properties[k] = delegateSpec.properties[k]; }); |
| } |
| // if set a new delegateSpec, shoulde check whether need to |
| // trigger hasTask or not |
| if (isNewDelegate && this.lastTaskState && |
| (this.lastTaskState.macroTask || this.lastTaskState.microTask)) { |
| this.isNeedToTriggerHasTask = true; |
| } |
| }; |
| ProxyZoneSpec.prototype.getDelegate = function () { |
| return this._delegateSpec; |
| }; |
| ProxyZoneSpec.prototype.resetDelegate = function () { |
| var delegateSpec = this.getDelegate(); |
| this.setDelegate(this.defaultSpecDelegate); |
| }; |
| ProxyZoneSpec.prototype.tryTriggerHasTask = function (parentZoneDelegate, currentZone, targetZone) { |
| if (this.isNeedToTriggerHasTask && this.lastTaskState) { |
| // last delegateSpec has microTask or macroTask |
| // should call onHasTask in current delegateSpec |
| this.isNeedToTriggerHasTask = false; |
| this.onHasTask(parentZoneDelegate, currentZone, targetZone, this.lastTaskState); |
| } |
| }; |
| ProxyZoneSpec.prototype.removeFromTasks = function (task) { |
| if (!this.tasks) { |
| return; |
| } |
| for (var i = 0; i < this.tasks.length; i++) { |
| if (this.tasks[i] === task) { |
| this.tasks.splice(i, 1); |
| return; |
| } |
| } |
| }; |
| ProxyZoneSpec.prototype.getAndClearPendingTasksInfo = function () { |
| if (this.tasks.length === 0) { |
| return ''; |
| } |
| var taskInfo = this.tasks.map(function (task) { |
| var dataInfo = task.data && |
| Object.keys(task.data) |
| .map(function (key) { |
| return key + ':' + task.data[key]; |
| }) |
| .join(','); |
| return "type: " + task.type + ", source: " + task.source + ", args: {" + dataInfo + "}"; |
| }); |
| var pendingTasksInfo = '--Pendng async tasks are: [' + taskInfo + ']'; |
| // clear tasks |
| this.tasks = []; |
| return pendingTasksInfo; |
| }; |
| ProxyZoneSpec.prototype.onFork = function (parentZoneDelegate, currentZone, targetZone, zoneSpec) { |
| if (this._delegateSpec && this._delegateSpec.onFork) { |
| return this._delegateSpec.onFork(parentZoneDelegate, currentZone, targetZone, zoneSpec); |
| } |
| else { |
| return parentZoneDelegate.fork(targetZone, zoneSpec); |
| } |
| }; |
| ProxyZoneSpec.prototype.onIntercept = function (parentZoneDelegate, currentZone, targetZone, delegate, source) { |
| if (this._delegateSpec && this._delegateSpec.onIntercept) { |
| return this._delegateSpec.onIntercept(parentZoneDelegate, currentZone, targetZone, delegate, source); |
| } |
| else { |
| return parentZoneDelegate.intercept(targetZone, delegate, source); |
| } |
| }; |
| ProxyZoneSpec.prototype.onInvoke = function (parentZoneDelegate, currentZone, targetZone, delegate, applyThis, applyArgs, source) { |
| this.tryTriggerHasTask(parentZoneDelegate, currentZone, targetZone); |
| if (this._delegateSpec && this._delegateSpec.onInvoke) { |
| return this._delegateSpec.onInvoke(parentZoneDelegate, currentZone, targetZone, delegate, applyThis, applyArgs, source); |
| } |
| else { |
| return parentZoneDelegate.invoke(targetZone, delegate, applyThis, applyArgs, source); |
| } |
| }; |
| ProxyZoneSpec.prototype.onHandleError = function (parentZoneDelegate, currentZone, targetZone, error) { |
| if (this._delegateSpec && this._delegateSpec.onHandleError) { |
| return this._delegateSpec.onHandleError(parentZoneDelegate, currentZone, targetZone, error); |
| } |
| else { |
| return parentZoneDelegate.handleError(targetZone, error); |
| } |
| }; |
| ProxyZoneSpec.prototype.onScheduleTask = function (parentZoneDelegate, currentZone, targetZone, task) { |
| if (task.type !== 'eventTask') { |
| this.tasks.push(task); |
| } |
| if (this._delegateSpec && this._delegateSpec.onScheduleTask) { |
| return this._delegateSpec.onScheduleTask(parentZoneDelegate, currentZone, targetZone, task); |
| } |
| else { |
| return parentZoneDelegate.scheduleTask(targetZone, task); |
| } |
| }; |
| ProxyZoneSpec.prototype.onInvokeTask = function (parentZoneDelegate, currentZone, targetZone, task, applyThis, applyArgs) { |
| if (task.type !== 'eventTask') { |
| this.removeFromTasks(task); |
| } |
| this.tryTriggerHasTask(parentZoneDelegate, currentZone, targetZone); |
| if (this._delegateSpec && this._delegateSpec.onInvokeTask) { |
| return this._delegateSpec.onInvokeTask(parentZoneDelegate, currentZone, targetZone, task, applyThis, applyArgs); |
| } |
| else { |
| return parentZoneDelegate.invokeTask(targetZone, task, applyThis, applyArgs); |
| } |
| }; |
| ProxyZoneSpec.prototype.onCancelTask = function (parentZoneDelegate, currentZone, targetZone, task) { |
| if (task.type !== 'eventTask') { |
| this.removeFromTasks(task); |
| } |
| this.tryTriggerHasTask(parentZoneDelegate, currentZone, targetZone); |
| if (this._delegateSpec && this._delegateSpec.onCancelTask) { |
| return this._delegateSpec.onCancelTask(parentZoneDelegate, currentZone, targetZone, task); |
| } |
| else { |
| return parentZoneDelegate.cancelTask(targetZone, task); |
| } |
| }; |
| ProxyZoneSpec.prototype.onHasTask = function (delegate, current, target, hasTaskState) { |
| this.lastTaskState = hasTaskState; |
| if (this._delegateSpec && this._delegateSpec.onHasTask) { |
| this._delegateSpec.onHasTask(delegate, current, target, hasTaskState); |
| } |
| else { |
| delegate.hasTask(target, hasTaskState); |
| } |
| }; |
| return ProxyZoneSpec; |
| }()); |
| // Export the class so that new instances can be created with proper |
| // constructor params. |
| Zone['ProxyZoneSpec'] = ProxyZoneSpec; |
| |
| }))); |