Function ɵzoneWrap

src/zones.ts:124–193

(it: T, blockUntilFirst: boolean, logLevel?: LogLevel)

};

export const ɵzoneWrap = <T= unknown>(it: T, blockUntilFirst: boolean, logLevel?: LogLevel): T => {
  logLevel ||= blockUntilFirst ? LogLevel.WARN : LogLevel.VERBOSE;
  // function() is needed for the arguments object
  return function () {
    let taskDone: VoidFunction | undefined;
    const _arguments = arguments;
    let schedulers: ɵAngularFireSchedulers;
    let pendingTasks: PendingTasks;
    let injector: EnvironmentInjector;
    try {
      schedulers = inject(ɵAngularFireSchedulers);
      pendingTasks = inject(PendingTasks);
      injector = inject(EnvironmentInjector);
    } catch(e) {
      warnOutsideInjectionContext(it, logLevel);
      return (it as any).apply(this, _arguments);
    }
    // if this is a callback function, e.g, onSnapshot, we should create a pending task and complete it
    // only once one of the callback functions is tripped.
    for (let i = 0; i < arguments.length; i++) {
      if (typeof _arguments[i] === 'function') {
        if (blockUntilFirst) {
          taskDone ||= run(() => pendingTasks.add());
        }
        // TODO create a microtask to track callback functions
        _arguments[i] = zoneWrapFn(_arguments[i], taskDone, injector);
      }
    }
    const ret = runOutsideAngular(() => (it as any).apply(this, _arguments));
    if (!blockUntilFirst) {
      if (ret instanceof Observable) {
        return ret.pipe(
          subscribeOn(schedulers.outsideAngular),
          observeOn(schedulers.insideAngular),
        );
      } else {
        return run(() => ret);
      }
    }
    if (ret instanceof Observable) {
      return ret.pipe(
        subscribeOn(schedulers.outsideAngular),
        observeOn(schedulers.insideAngular),
        pendingUntilEvent(injector),
      );
    } else if (ret instanceof Promise) {
      // eslint-disable-next-line @typescript-eslint/no-misused-promises
      return run(
        () => {
          const removeTask = pendingTasks.add();
          return new Promise((resolve, reject) => {
            ret.then(
              (it) => runInInjectionContext(injector, () => run(() => resolve(it))),
              (reason) => runInInjectionContext(injector, () => run(() => reject(reason)))
            ).finally(removeTask);
        });
      });
    } else if (typeof ret === 'function' && taskDone) {