angular/packages/zone.js/lib/common/fetch.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
 */
/**
 * @fileoverview
 * @suppress {missingRequire}
 */

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(
                    (resource: any) => {
                      if (task.state !== 'notScheduled') {
                        task.invoke();
                      }
                      resolve(resource);
                    },
                    (error: any) => {
                      if (task.state !== 'notScheduled') {
                        task.invoke();
                      }
                      reject(error);
                    });
              },
              () => {
                ac?.abort();
              });
        });

    global['fetch'] = function() {
      const args = Array.prototype.slice.call(arguments);
      const options = args.length > 1 ? args[1] : {};
      const signal: AbortSignal|undefined = options?.signal;
      const ac = new AbortController();
      const fetchSignal = ac.signal;
      options.signal = fetchSignal;
      args[1] = options;

      if (signal) {
        const nativeAddEventListener =
            signal[Zone.__symbol__('addEventListener') as 'addEventListener'] ||
            signal.addEventListener;

        nativeAddEventListener.call(signal, 'abort', function() {
          ac!.abort();
        }, {once: true});
      }

      return createFetchTask('fetch', {fetchArgs: args} as FetchTaskData, fetch, this, args, ac);
    };

    if (OriginalResponse?.prototype) {
      // https://fetch.spec.whatwg.org/#body-mixin
      ['arrayBuffer', 'blob', 'formData', 'json', 'text']
          // Safely check whether the method exists on the `Response` prototype before patching.
          .filter(method => typeof OriginalResponse.prototype[method] === 'function')
          .forEach(method => {
            api.patchMethod(
                OriginalResponse.prototype, method,
                (delegate: Function) => (self, args) => createFetchTask(
                    `Response.${method}`, undefined, delegate, self, args, undefined));
          });
    }
  });
}