angular/packages/zone.js/lib/extra/jsonp.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.dev/license
 */

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

export function patchJsonp(Zone: ZoneType): void {
  Zone.__load_patch('jsonp', (global: any, Zone: ZoneType, api: _ZonePrivate) => {
    const noop = function () {};
    // because jsonp is not a standard api, there are a lot of
    // implementations, so zone.js just provide a helper util to
    // patch the jsonp send and onSuccess/onError callback
    // the options is an object which contains
    // - jsonp, the jsonp object which hold the send function
    // - sendFuncName, the name of the send function
    // - successFuncName, success func name
    // - failedFuncName, failed func name
    (Zone as any)[Zone.__symbol__('jsonp')] = function patchJsonp(options: any) {
      if (!options || !options.jsonp || !options.sendFuncName) {
        return;
      }
      const noop = function () {};

      [options.successFuncName, options.failedFuncName].forEach((methodName) => {
        if (!methodName) {
          return;
        }

        const oriFunc = global[methodName];
        if (oriFunc) {
          api.patchMethod(global, methodName, (delegate: Function) => (self: any, args: any[]) => {
            const task = global[api.symbol('jsonTask')];
            if (task) {
              task.callback = delegate;
              return task.invoke.apply(self, args);
            } else {
              return delegate.apply(self, args);
            }
          });
        } else {
          Object.defineProperty(global, methodName, {
            configurable: true,
            enumerable: true,
            get: function () {
              return function (this: unknown) {
                const task = global[api.symbol('jsonpTask')];
                const target = this ? this : global;
                const delegate = global[api.symbol(`jsonp${methodName}callback`)];

                if (task) {
                  if (delegate) {
                    task.callback = delegate;
                  }
                  global[api.symbol('jsonpTask')] = undefined;
                  return task.invoke.apply(this, arguments);
                } else {
                  if (delegate) {
                    return delegate.apply(this, arguments);
                  }
                }
                return null;
              };
            },
            set: function (callback: Function) {
              this[api.symbol(`jsonp${methodName}callback`)] = callback;
            },
          });
        }
      });

      api.patchMethod(
        options.jsonp,
        options.sendFuncName,
        (delegate: Function) => (self: any, args: any[]) => {
          global[api.symbol('jsonpTask')] = Zone.current.scheduleMacroTask(
            'jsonp',
            noop,
            {},
            (task: Task) => {
              return delegate.apply(self, args);
            },
            noop,
          );
        },
      );
    };
  });
}