Function patchPromise

packages/zone.js/lib/common/promise.ts:12–642

(Zone: ZoneType)

import {patchMethod} from './utils';

export function patchPromise(Zone: ZoneType): void {
  Zone.__load_patch('ZoneAwarePromise', (global: any, Zone: ZoneType, api: _ZonePrivate) => {
    const ObjectGetOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
    const ObjectDefineProperty = Object.defineProperty;

    function readableObjectToString(obj: any) {
      if (obj && obj.toString === Object.prototype.toString) {
        const className = obj.constructor && obj.constructor.name;
        return (className ? className : '') + ': ' + JSON.stringify(obj);
      }

      return obj ? obj.toString() : Object.prototype.toString.call(obj);
    }

    const __symbol__ = api.symbol;
    const _uncaughtPromiseErrors: UncaughtPromiseError[] = [];
    const isDisableWrappingUncaughtPromiseRejection =
      global[__symbol__('DISABLE_WRAPPING_UNCAUGHT_PROMISE_REJECTION')] !== false;
    const symbolPromise = __symbol__('Promise');
    const symbolThen = __symbol__('then');
    const creationTrace = '__creationTrace__';

    api.onUnhandledError = (e: any) => {
      if (api.showUncaughtError()) {
        const rejection = e && e.rejection;
        if (rejection && e.zone && e.task) {
          console.error(
            'Unhandled Promise rejection:',
            rejection instanceof Error ? rejection.message : rejection,
            '; Zone:',
            (<Zone>e.zone).name,
            '; Task:',
            e.task && (<Task>e.task).source,
            '; Value:',
            rejection,
            rejection instanceof Error ? rejection.stack : undefined,
          );
        } else {
          console.error(e);
        }
      }
    };

    api.microtaskDrainDone = () => {
      while (_uncaughtPromiseErrors.length) {
        const uncaughtPromiseError: UncaughtPromiseError = _uncaughtPromiseErrors.shift()!;
        try {
          uncaughtPromiseError.zone.runGuarded(() => {
            if (uncaughtPromiseError.throwOriginal) {
              throw uncaughtPromiseError.rejection;
            }
            throw uncaughtPromiseError;
          });
        } catch (error) {
          handleUnhandledRejection(error);
        }
      }
    };