Function patchFetch

packages/zone.js/lib/common/fetch.ts:15–144

(Zone: ZoneType)

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

export function patchFetch(Zone: ZoneType): void {
  Zone.__load_patch('fetch', (global: any, Zone: ZoneType, api: _ZonePrivate) => {
    interface FetchTaskData extends TaskData {
      fetchArgs?: any[];
    }
    let fetch = global['fetch'];
    if (typeof fetch !== 'function') {
      return;
    }
    const originalFetch = global[api.symbol('fetch')];
    if (originalFetch) {
      // restore unpatched fetch first
      fetch = originalFetch;
    }
    const ZoneAwarePromise = global.Promise;
    const symbolThenPatched = api.symbol('thenPatched');
    const fetchTaskScheduling = api.symbol('fetchTaskScheduling');
    const OriginalResponse = global.Response;
    const placeholder = function () {};

    const createFetchTask = (
      source: string,
      data: TaskData | undefined,
      originalImpl: any,
      self: any,
      args: any[],
      ac?: AbortController,
    ) =>
      new Promise((resolve, reject) => {
        const task = Zone.current.scheduleMacroTask(
          source,
          placeholder,
          data,
          () => {
            // The promise object returned by the original implementation passed into the
            // function. This might be a `fetch` promise, `Response.prototype.json` promise,
            // etc.
            let implPromise;
            let zone = Zone.current;

            try {
              (zone as any)[fetchTaskScheduling] = true;
              implPromise = originalImpl.apply(self, args);
            } catch (error) {
              reject(error);
              return;
            } finally {
              (zone as any)[fetchTaskScheduling] = false;
            }

            if (!(implPromise instanceof ZoneAwarePromise)) {
              let ctor = implPromise.constructor;
              if (!ctor[symbolThenPatched]) {
                api.patchThen(ctor);
              }
            }

            implPromise.then(