异步函数外部堆栈上下文

function installAsyncTrack() {
  /* global Promise: true */
  if (Promise.isAsyncTracker) throw new Error('Only one tracker can be installed');

  const RootPromise = Promise.isAsyncTracker ? Promise.rootPromise : Promise;
  let active = true;

  const tracker = {
    track(f, o, ...args) {
      const prevObj = tracker.trackObj;
      tracker.trackObj = o;
      try {
        return f.apply(this, args);
      } finally {
        tracker.trackObj = prevObj;
      }
    },
    trackObj: undefined,
    uninstall() {
      active = false;
      if (Promise === AsyncTrackPromise.prevPromise) return;
      if (Promise !== AsyncTrackPromise) return;
      Promise = AsyncTrackPromise.prevPromise;
    }
  };

  AsyncTrackPromise.prototype = Object.create(Promise);
  AsyncTrackPromise.rootPromise = RootPromise;
  AsyncTrackPromise.prevPromise = Promise;
  Promise = AsyncTrackPromise;
  AsyncTrackPromise.resolve = value => {
    return new AsyncTrackPromise(resolve => resolve(value));
  };
  AsyncTrackPromise.reject = val => {
    return new AsyncTrackPromise((resolve, reject) => reject(value));
  };
  AsyncTrackPromise.all = iterable => {
    const promises = Array.from(iterable);
    if (!promises.length) return AsyncTrackPromise.resolve();
    return new AsyncTrackPromise((resolve, reject) => {
      let rejected = false;
      let results = new Array(promises.length);
      let done = 0;
      const allPromises = promises.map(promise => {
        if (promise && typeof promise.then === 'function') {
          return promise;
        }
        return new AsyncTrackPromise.resolve(promise);
      });
      allPromises.forEach((promise, ix) => {
        promise.then(value => {
          if (rejected) return;
          results[ix] = value;
          done++;
          if (done === results.length) {
            resolve(results);
          }
        }, reason => {
          if (rejected) return;
          rejected = true;
          reject(reason);
        });
      });
    });
  };
  AsyncTrackPromise.race = iterable => {
    const promises = Array.from(iterable);
    if (!promises.length) return new AsyncTrackPromise(() => {});
    return new AsyncTrackPromise((resolve, reject) => {
      let resolved = false;
      if (promises.some(promise => {
          if (!promise || typeof promise.then !== 'function') {
            resolve(promise);
            return true;
          }
        })) return;
      promises.forEach((promise, ix) => {
        promise.then(value => {
          if (resolved) return;
          resolved = true;
          resolve(value);
        }, reason => {
          if (resolved) return;
          resolved = true;
          reject(reason);
        });
      });
    });
  };

  function AsyncTrackPromise(handler) {
    const promise = new RootPromise(handler);
    promise.trackObj = tracker.trackObj;

    promise.origThen = promise.then;
    promise.then = thenOverride;

    promise.origCatch = promise.catch;
    promise.catch = catchOverride;

    if (promise.finally) {
      promise.origFinally = promise.finally;
      promise.finally = finallyOverride;
    }
    return promise;
  }

  AsyncTrackPromise.isAsyncTracker = true;

  function thenOverride(resolve, reject) {
    const trackObj = this.trackObj;
    if (!active || trackObj === undefined) return this.origThen.apply(this, arguments);
    return this.origThen.call(
      this,
      myResolver(trackObj, resolve),
      reject && myResolver(trackObj, reject)
    );
  }

  function catchOverride(reject) {
    const trackObj = this.trackObj;
    if (!active || trackObj === undefined) return this.origCatch.catch.apply(this, arguments);
    return this.origCatch.call(
      this,
      myResolver(trackObj, reject)
    );
  }

  function finallyOverride(callback) {
    const trackObj = this.trackObj;
    if (!active || trackObj === undefined) return this.origCatch.catch.apply(this, arguments);
    return this.origCatch.call(
      this,
      myResolver(trackObj, reject)
    );
  }

  return tracker;

  function myResolver(trackObj, resolve) {
    return function myResolve(val) {
      if (trackObj === undefined) {
        return resolve(val);
      }
      RootPromise.resolve().then(() => {
        const prevObj = tracker.trackObj;
        tracker.trackObj = trackObj;
        RootPromise.resolve().then(() => {
          tracker.trackObj = prevObj;
        });
      });
      const prevObj = tracker.trackObj;
      tracker.trackObj = trackObj;
      try {
        return resolve(val);
      } finally {
        tracker.trackObj = prevObj;
      }
    };
  }

}

tracker = installAsyncTrack();

function track(func, value, ...args) {
  return tracker.track(func, { value }, value, ...args);
}

function show(where, which) {
  console.log('At call', where, 'from', which, 'the value is: ', tracker.trackObj && tracker.trackObj.value);
}

async function test(which, sub) {
  show(1, which);
  await delay(Math.random() * 100);
  show(2, which);
  if (sub === 'resolve') {
    await Promise.resolve(test('sub'));
    show(3, which);
  }
  if (sub === 'call') {
    await test(which + ' sub');
    show(3, which);
  }
}

function delay(ms) {
  return new Promise(resolve => setTimeout(resolve, ms));
}

track(test, 'test1');
track(test, 'test2');
track(test, 'test3', 'resolve');
track(test, 'test4', 'call');