| 'use strict'; |
| /** |
| * @license Angular v12.0.0-next.0 |
| * (c) 2010-2020 Google LLC. https://angular.io/ |
| * License: MIT |
| */ |
| /** |
| * @license |
| * Copyright Google LLC 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 |
| */ |
| /** |
| * @fileoverview |
| * @suppress {globalThis,undefinedVars} |
| */ |
| Zone.__load_patch('Error', (global, Zone, api) => { |
| /* |
| * This code patches Error so that: |
| * - It ignores un-needed stack frames. |
| * - It Shows the associated Zone for reach frame. |
| */ |
| const zoneJsInternalStackFramesSymbol = api.symbol('zoneJsInternalStackFrames'); |
| const NativeError = global[api.symbol('Error')] = global['Error']; |
| // Store the frames which should be removed from the stack frames |
| const zoneJsInternalStackFrames = {}; |
| // We must find the frame where Error was created, otherwise we assume we don't understand stack |
| let zoneAwareFrame1; |
| let zoneAwareFrame2; |
| let zoneAwareFrame1WithoutNew; |
| let zoneAwareFrame2WithoutNew; |
| let zoneAwareFrame3WithoutNew; |
| global['Error'] = ZoneAwareError; |
| const stackRewrite = 'stackRewrite'; |
| const zoneJsInternalStackFramesPolicy = global['__Zone_Error_BlacklistedStackFrames_policy'] || |
| global['__Zone_Error_ZoneJsInternalStackFrames_policy'] || 'default'; |
| function buildZoneFrameNames(zoneFrame) { |
| let zoneFrameName = { zoneName: zoneFrame.zone.name }; |
| let result = zoneFrameName; |
| while (zoneFrame.parent) { |
| zoneFrame = zoneFrame.parent; |
| const parentZoneFrameName = { zoneName: zoneFrame.zone.name }; |
| zoneFrameName.parent = parentZoneFrameName; |
| zoneFrameName = parentZoneFrameName; |
| } |
| return result; |
| } |
| function buildZoneAwareStackFrames(originalStack, zoneFrame, isZoneFrame = true) { |
| let frames = originalStack.split('\n'); |
| let i = 0; |
| // Find the first frame |
| while (!(frames[i] === zoneAwareFrame1 || frames[i] === zoneAwareFrame2 || |
| frames[i] === zoneAwareFrame1WithoutNew || frames[i] === zoneAwareFrame2WithoutNew || |
| frames[i] === zoneAwareFrame3WithoutNew) && |
| i < frames.length) { |
| i++; |
| } |
| for (; i < frames.length && zoneFrame; i++) { |
| let frame = frames[i]; |
| if (frame.trim()) { |
| switch (zoneJsInternalStackFrames[frame]) { |
| case 0 /* zoneJsInternal */: |
| frames.splice(i, 1); |
| i--; |
| break; |
| case 1 /* transition */: |
| if (zoneFrame.parent) { |
| // This is the special frame where zone changed. Print and process it accordingly |
| zoneFrame = zoneFrame.parent; |
| } |
| else { |
| zoneFrame = null; |
| } |
| frames.splice(i, 1); |
| i--; |
| break; |
| default: |
| frames[i] += isZoneFrame ? ` [${zoneFrame.zone.name}]` : |
| ` [${zoneFrame.zoneName}]`; |
| } |
| } |
| } |
| return frames.join('\n'); |
| } |
| /** |
| * This is ZoneAwareError which processes the stack frame and cleans up extra frames as well as |
| * adds zone information to it. |
| */ |
| function ZoneAwareError() { |
| // We always have to return native error otherwise the browser console will not work. |
| let error = NativeError.apply(this, arguments); |
| // Save original stack trace |
| const originalStack = error['originalStack'] = error.stack; |
| // Process the stack trace and rewrite the frames. |
| if (ZoneAwareError[stackRewrite] && originalStack) { |
| let zoneFrame = api.currentZoneFrame(); |
| if (zoneJsInternalStackFramesPolicy === 'lazy') { |
| // don't handle stack trace now |
| error[api.symbol('zoneFrameNames')] = buildZoneFrameNames(zoneFrame); |
| } |
| else if (zoneJsInternalStackFramesPolicy === 'default') { |
| try { |
| error.stack = error.zoneAwareStack = buildZoneAwareStackFrames(originalStack, zoneFrame); |
| } |
| catch (e) { |
| // ignore as some browsers don't allow overriding of stack |
| } |
| } |
| } |
| if (this instanceof NativeError && this.constructor != NativeError) { |
| // We got called with a `new` operator AND we are subclass of ZoneAwareError |
| // in that case we have to copy all of our properties to `this`. |
| Object.keys(error).concat('stack', 'message').forEach((key) => { |
| const value = error[key]; |
| if (value !== undefined) { |
| try { |
| this[key] = value; |
| } |
| catch (e) { |
| // ignore the assignment in case it is a setter and it throws. |
| } |
| } |
| }); |
| return this; |
| } |
| return error; |
| } |
| // Copy the prototype so that instanceof operator works as expected |
| ZoneAwareError.prototype = NativeError.prototype; |
| ZoneAwareError[zoneJsInternalStackFramesSymbol] = zoneJsInternalStackFrames; |
| ZoneAwareError[stackRewrite] = false; |
| const zoneAwareStackSymbol = api.symbol('zoneAwareStack'); |
| // try to define zoneAwareStack property when zoneJsInternal frames policy is delay |
| if (zoneJsInternalStackFramesPolicy === 'lazy') { |
| Object.defineProperty(ZoneAwareError.prototype, 'zoneAwareStack', { |
| configurable: true, |
| enumerable: true, |
| get: function () { |
| if (!this[zoneAwareStackSymbol]) { |
| this[zoneAwareStackSymbol] = buildZoneAwareStackFrames(this.originalStack, this[api.symbol('zoneFrameNames')], false); |
| } |
| return this[zoneAwareStackSymbol]; |
| }, |
| set: function (newStack) { |
| this.originalStack = newStack; |
| this[zoneAwareStackSymbol] = buildZoneAwareStackFrames(this.originalStack, this[api.symbol('zoneFrameNames')], false); |
| } |
| }); |
| } |
| // those properties need special handling |
| const specialPropertyNames = ['stackTraceLimit', 'captureStackTrace', 'prepareStackTrace']; |
| // those properties of NativeError should be set to ZoneAwareError |
| const nativeErrorProperties = Object.keys(NativeError); |
| if (nativeErrorProperties) { |
| nativeErrorProperties.forEach(prop => { |
| if (specialPropertyNames.filter(sp => sp === prop).length === 0) { |
| Object.defineProperty(ZoneAwareError, prop, { |
| get: function () { |
| return NativeError[prop]; |
| }, |
| set: function (value) { |
| NativeError[prop] = value; |
| } |
| }); |
| } |
| }); |
| } |
| if (NativeError.hasOwnProperty('stackTraceLimit')) { |
| // Extend default stack limit as we will be removing few frames. |
| NativeError.stackTraceLimit = Math.max(NativeError.stackTraceLimit, 15); |
| // make sure that ZoneAwareError has the same property which forwards to NativeError. |
| Object.defineProperty(ZoneAwareError, 'stackTraceLimit', { |
| get: function () { |
| return NativeError.stackTraceLimit; |
| }, |
| set: function (value) { |
| return NativeError.stackTraceLimit = value; |
| } |
| }); |
| } |
| if (NativeError.hasOwnProperty('captureStackTrace')) { |
| Object.defineProperty(ZoneAwareError, 'captureStackTrace', { |
| // add named function here because we need to remove this |
| // stack frame when prepareStackTrace below |
| value: function zoneCaptureStackTrace(targetObject, constructorOpt) { |
| NativeError.captureStackTrace(targetObject, constructorOpt); |
| } |
| }); |
| } |
| const ZONE_CAPTURESTACKTRACE = 'zoneCaptureStackTrace'; |
| Object.defineProperty(ZoneAwareError, 'prepareStackTrace', { |
| get: function () { |
| return NativeError.prepareStackTrace; |
| }, |
| set: function (value) { |
| if (!value || typeof value !== 'function') { |
| return NativeError.prepareStackTrace = value; |
| } |
| return NativeError.prepareStackTrace = function (error, structuredStackTrace) { |
| // remove additional stack information from ZoneAwareError.captureStackTrace |
| if (structuredStackTrace) { |
| for (let i = 0; i < structuredStackTrace.length; i++) { |
| const st = structuredStackTrace[i]; |
| // remove the first function which name is zoneCaptureStackTrace |
| if (st.getFunctionName() === ZONE_CAPTURESTACKTRACE) { |
| structuredStackTrace.splice(i, 1); |
| break; |
| } |
| } |
| } |
| return value.call(this, error, structuredStackTrace); |
| }; |
| } |
| }); |
| if (zoneJsInternalStackFramesPolicy === 'disable') { |
| // don't need to run detectZone to populate zoneJs internal stack frames |
| return; |
| } |
| // Now we need to populate the `zoneJsInternalStackFrames` as well as find the |
| // run/runGuarded/runTask frames. This is done by creating a detect zone and then threading |
| // the execution through all of the above methods so that we can look at the stack trace and |
| // find the frames of interest. |
| let detectZone = Zone.current.fork({ |
| name: 'detect', |
| onHandleError: function (parentZD, current, target, error) { |
| if (error.originalStack && Error === ZoneAwareError) { |
| let frames = error.originalStack.split(/\n/); |
| let runFrame = false, runGuardedFrame = false, runTaskFrame = false; |
| while (frames.length) { |
| let frame = frames.shift(); |
| // On safari it is possible to have stack frame with no line number. |
| // This check makes sure that we don't filter frames on name only (must have |
| // line number or exact equals to `ZoneAwareError`) |
| if (/:\d+:\d+/.test(frame) || frame === 'ZoneAwareError') { |
| // Get rid of the path so that we don't accidentally find function name in path. |
| // In chrome the separator is `(` and `@` in FF and safari |
| // Chrome: at Zone.run (zone.js:100) |
| // Chrome: at Zone.run (http://localhost:9876/base/build/lib/zone.js:100:24) |
| // FireFox: Zone.prototype.run@http://localhost:9876/base/build/lib/zone.js:101:24 |
| // Safari: run@http://localhost:9876/base/build/lib/zone.js:101:24 |
| let fnName = frame.split('(')[0].split('@')[0]; |
| let frameType = 1 /* transition */; |
| if (fnName.indexOf('ZoneAwareError') !== -1) { |
| if (fnName.indexOf('new ZoneAwareError') !== -1) { |
| zoneAwareFrame1 = frame; |
| zoneAwareFrame2 = frame.replace('new ZoneAwareError', 'new Error.ZoneAwareError'); |
| } |
| else { |
| zoneAwareFrame1WithoutNew = frame; |
| zoneAwareFrame2WithoutNew = frame.replace('Error.', ''); |
| if (frame.indexOf('Error.ZoneAwareError') === -1) { |
| zoneAwareFrame3WithoutNew = |
| frame.replace('ZoneAwareError', 'Error.ZoneAwareError'); |
| } |
| } |
| zoneJsInternalStackFrames[zoneAwareFrame2] = 0 /* zoneJsInternal */; |
| } |
| if (fnName.indexOf('runGuarded') !== -1) { |
| runGuardedFrame = true; |
| } |
| else if (fnName.indexOf('runTask') !== -1) { |
| runTaskFrame = true; |
| } |
| else if (fnName.indexOf('run') !== -1) { |
| runFrame = true; |
| } |
| else { |
| frameType = 0 /* zoneJsInternal */; |
| } |
| zoneJsInternalStackFrames[frame] = frameType; |
| // Once we find all of the frames we can stop looking. |
| if (runFrame && runGuardedFrame && runTaskFrame) { |
| ZoneAwareError[stackRewrite] = true; |
| break; |
| } |
| } |
| } |
| } |
| return false; |
| } |
| }); |
| // carefully constructor a stack frame which contains all of the frames of interest which |
| // need to be detected and marked as an internal zoneJs frame. |
| const childDetectZone = detectZone.fork({ |
| name: 'child', |
| onScheduleTask: function (delegate, curr, target, task) { |
| return delegate.scheduleTask(target, task); |
| }, |
| onInvokeTask: function (delegate, curr, target, task, applyThis, applyArgs) { |
| return delegate.invokeTask(target, task, applyThis, applyArgs); |
| }, |
| onCancelTask: function (delegate, curr, target, task) { |
| return delegate.cancelTask(target, task); |
| }, |
| onInvoke: function (delegate, curr, target, callback, applyThis, applyArgs, source) { |
| return delegate.invoke(target, callback, applyThis, applyArgs, source); |
| } |
| }); |
| // we need to detect all zone related frames, it will |
| // exceed default stackTraceLimit, so we set it to |
| // larger number here, and restore it after detect finish. |
| // We cast through any so we don't need to depend on nodejs typings. |
| const originalStackTraceLimit = Error.stackTraceLimit; |
| Error.stackTraceLimit = 100; |
| // we schedule event/micro/macro task, and invoke them |
| // when onSchedule, so we can get all stack traces for |
| // all kinds of tasks with one error thrown. |
| childDetectZone.run(() => { |
| childDetectZone.runGuarded(() => { |
| const fakeTransitionTo = () => { }; |
| childDetectZone.scheduleEventTask(zoneJsInternalStackFramesSymbol, () => { |
| childDetectZone.scheduleMacroTask(zoneJsInternalStackFramesSymbol, () => { |
| childDetectZone.scheduleMicroTask(zoneJsInternalStackFramesSymbol, () => { |
| throw new Error(); |
| }, undefined, (t) => { |
| t._transitionTo = fakeTransitionTo; |
| t.invoke(); |
| }); |
| childDetectZone.scheduleMicroTask(zoneJsInternalStackFramesSymbol, () => { |
| throw Error(); |
| }, undefined, (t) => { |
| t._transitionTo = fakeTransitionTo; |
| t.invoke(); |
| }); |
| }, undefined, (t) => { |
| t._transitionTo = fakeTransitionTo; |
| t.invoke(); |
| }, () => { }); |
| }, undefined, (t) => { |
| t._transitionTo = fakeTransitionTo; |
| t.invoke(); |
| }, () => { }); |
| }); |
| }); |
| Error.stackTraceLimit = originalStackTraceLimit; |
| }); |
