angular__angular/packages/zone.js/lib/extra/bluebird.ts

/**
 * @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
 */

import {ZoneType} from '../zone-impl';

export function patchBluebird(Zone: ZoneType): void {
  Zone.__load_patch('bluebird', (global: any, Zone: ZoneType, api: _ZonePrivate) => {
    // TODO: @JiaLiPassion, we can automatically patch bluebird
    // if global.Promise = Bluebird, but sometimes in nodejs,
    // global.Promise is not Bluebird, and Bluebird is just be
    // used by other libraries such as sequelize, so I think it is
    // safe to just expose a method to patch Bluebird explicitly
    const BLUEBIRD = 'bluebird';
    (Zone as any)[Zone.__symbol__(BLUEBIRD)] = function patchBluebird(Bluebird: any) {
      // patch method of Bluebird.prototype which not using `then` internally
      const bluebirdApis: string[] = ['then', 'spread', 'finally'];
      bluebirdApis.forEach(bapi => {
        api.patchMethod(
            Bluebird.prototype, bapi, (delegate: Function) => (self: any, args: any[]) => {
              const zone = Zone.current;
              for (let i = 0; i < args.length; i++) {
                const func = args[i];
                if (typeof func === 'function') {
                  args[i] = function() {
                    const argSelf: any = this;
                    const argArgs: any = arguments;
                    return new Bluebird((res: any, rej: any) => {
                      zone.scheduleMicroTask('Promise.then', () => {
                        try {
                          res(func.apply(argSelf, argArgs));
                        } catch (error) {
                          rej(error);
                        }
                      });
                    });
                  };
                }
              }
              return delegate.apply(self, args);
            });
      });

      if (typeof window !== 'undefined') {
        window.addEventListener('unhandledrejection', function(event: any) {
          const error = event.detail && event.detail.reason;
          if (error && error.isHandledByZone) {
            event.preventDefault();
            if (typeof event.stopImmediatePropagation === 'function') {
              event.stopImmediatePropagation();
            }
          }
        });
      } else if (typeof process !== 'undefined') {
        process.on('unhandledRejection', (reason: any, p: any) => {
          if (reason && reason.isHandledByZone) {
            const listeners = process.listeners('unhandledRejection');
            if (listeners) {
              // remove unhandledRejection listeners so the callback
              // will not be triggered.
              process.removeAllListeners('unhandledRejection');
              process.nextTick(() => {
                listeners.forEach(listener => process.on('unhandledRejection', listener));
              });
            }
          }
        });
      }

      Bluebird.onPossiblyUnhandledRejection(function(e: any, promise: any) {
        try {
          Zone.current.runGuarded(() => {
            e.isHandledByZone = true;
            throw e;
          });
        } catch (err: any) {
          err.isHandledByZone = false;
          api.onUnhandledError(err);
        }
      });

      // override global promise
      global.Promise = Bluebird;
    };
  });
}