@angular/fire 7.6.0 → 16.0.0-canary.2d48ab0

package/esm2022/remote-config/remote-config.module.mjs

@@ -0,0 +1,86 @@
+import { APP_INITIALIZER, InjectionToken, Injector, NgModule, NgZone, Optional } from '@angular/core';
+import { VERSION, ɵAngularFireSchedulers, ɵgetDefaultInstanceOf } from '@angular/fire';
+import { FirebaseApp, FirebaseApps } from '@angular/fire/app';
+import { registerVersion } from 'firebase/app';
+import { isRemoteConfigSupportedFactory } from './is-remote-config-supported-factory';
+import { REMOTE_CONFIG_PROVIDER_NAME, RemoteConfig, RemoteConfigInstances } from './remote-config';
+import * as i0 from "@angular/core";
+export const PROVIDED_REMOTE_CONFIG_INSTANCES = new InjectionToken('angularfire2.remote-config-instances');
+export function defaultRemoteConfigInstanceFactory(provided, defaultApp) {
+    if (!isRemoteConfigSupportedFactory.sync()) {
+        return null;
+    }
+    const defaultRemoteConfig = ɵgetDefaultInstanceOf(REMOTE_CONFIG_PROVIDER_NAME, provided, defaultApp);
+    return defaultRemoteConfig && new RemoteConfig(defaultRemoteConfig);
+}
+export function remoteConfigInstanceFactory(fn) {
+    return (zone, injector) => {
+        if (!isRemoteConfigSupportedFactory.sync()) {
+            return null;
+        }
+        const remoteConfig = zone.runOutsideAngular(() => fn(injector));
+        return new RemoteConfig(remoteConfig);
+    };
+}
+const REMOTE_CONFIG_INSTANCES_PROVIDER = {
+    provide: RemoteConfigInstances,
+    deps: [
+        [new Optional(), PROVIDED_REMOTE_CONFIG_INSTANCES],
+    ]
+};
+const DEFAULT_REMOTE_CONFIG_INSTANCE_PROVIDER = {
+    provide: RemoteConfig,
+    useFactory: defaultRemoteConfigInstanceFactory,
+    deps: [
+        [new Optional(), PROVIDED_REMOTE_CONFIG_INSTANCES],
+        FirebaseApp,
+    ]
+};
+export class RemoteConfigModule {
+    constructor() {
+        registerVersion('angularfire', VERSION.full, 'rc');
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.10", ngImport: i0, type: RemoteConfigModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.2.10", ngImport: i0, type: RemoteConfigModule });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.2.10", ngImport: i0, type: RemoteConfigModule, providers: [
+            DEFAULT_REMOTE_CONFIG_INSTANCE_PROVIDER,
+            REMOTE_CONFIG_INSTANCES_PROVIDER,
+            {
+                provide: APP_INITIALIZER,
+                useValue: isRemoteConfigSupportedFactory.async,
+                multi: true,
+            },
+        ] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.10", ngImport: i0, type: RemoteConfigModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    providers: [
+                        DEFAULT_REMOTE_CONFIG_INSTANCE_PROVIDER,
+                        REMOTE_CONFIG_INSTANCES_PROVIDER,
+                        {
+                            provide: APP_INITIALIZER,
+                            useValue: isRemoteConfigSupportedFactory.async,
+                            multi: true,
+                        },
+                    ]
+                }]
+        }], ctorParameters: function () { return []; } });
+export function provideRemoteConfig(fn, ...deps) {
+    return {
+        ngModule: RemoteConfigModule,
+        providers: [{
+                provide: PROVIDED_REMOTE_CONFIG_INSTANCES,
+                useFactory: remoteConfigInstanceFactory(fn),
+                multi: true,
+                deps: [
+                    NgZone,
+                    Injector,
+                    ɵAngularFireSchedulers,
+                    FirebaseApps,
+                    ...deps,
+                ]
+            }]
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/{esm2015/storage/storage.js → esm2022/storage/storage.mjs}

@@ -13,4 +13,4 @@ export class StorageInstances {
     }
 }
 export const storageInstance$ = timer(0, 300).pipe(concatMap(() => from(ɵgetAllInstancesOf(STORAGE_PROVIDER_NAME))), distinct());
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/storage/storage.module.mjs

@@ -0,0 +1,74 @@
+import { InjectionToken, Injector, NgModule, NgZone, Optional } from '@angular/core';
+import { VERSION, ɵAngularFireSchedulers, ɵgetDefaultInstanceOf } from '@angular/fire';
+import { ɵAppCheckInstances } from '@angular/fire';
+import { FirebaseApp, FirebaseApps } from '@angular/fire/app';
+import { AuthInstances } from '@angular/fire/auth';
+import { registerVersion } from 'firebase/app';
+import { STORAGE_PROVIDER_NAME, Storage, StorageInstances } from './storage';
+import * as i0 from "@angular/core";
+export const PROVIDED_STORAGE_INSTANCES = new InjectionToken('angularfire2.storage-instances');
+export function defaultStorageInstanceFactory(provided, defaultApp) {
+    const defaultStorage = ɵgetDefaultInstanceOf(STORAGE_PROVIDER_NAME, provided, defaultApp);
+    return defaultStorage && new Storage(defaultStorage);
+}
+export function storageInstanceFactory(fn) {
+    return (zone, injector) => {
+        const storage = zone.runOutsideAngular(() => fn(injector));
+        return new Storage(storage);
+    };
+}
+const STORAGE_INSTANCES_PROVIDER = {
+    provide: StorageInstances,
+    deps: [
+        [new Optional(), PROVIDED_STORAGE_INSTANCES],
+    ]
+};
+const DEFAULT_STORAGE_INSTANCE_PROVIDER = {
+    provide: Storage,
+    useFactory: defaultStorageInstanceFactory,
+    deps: [
+        [new Optional(), PROVIDED_STORAGE_INSTANCES],
+        FirebaseApp,
+    ]
+};
+export class StorageModule {
+    constructor() {
+        registerVersion('angularfire', VERSION.full, 'gcs');
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.10", ngImport: i0, type: StorageModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.2.10", ngImport: i0, type: StorageModule });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.2.10", ngImport: i0, type: StorageModule, providers: [
+            DEFAULT_STORAGE_INSTANCE_PROVIDER,
+            STORAGE_INSTANCES_PROVIDER,
+        ] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.10", ngImport: i0, type: StorageModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    providers: [
+                        DEFAULT_STORAGE_INSTANCE_PROVIDER,
+                        STORAGE_INSTANCES_PROVIDER,
+                    ]
+                }]
+        }], ctorParameters: function () { return []; } });
+export function provideStorage(fn, ...deps) {
+    return {
+        ngModule: StorageModule,
+        providers: [{
+                provide: PROVIDED_STORAGE_INSTANCES,
+                useFactory: storageInstanceFactory(fn),
+                multi: true,
+                deps: [
+                    NgZone,
+                    Injector,
+                    ɵAngularFireSchedulers,
+                    FirebaseApps,
+                    // Defensively load Auth first, if provided
+                    [new Optional(), AuthInstances],
+                    [new Optional(), ɵAppCheckInstances],
+                    ...deps,
+                ]
+            }]
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/zones.mjs

@@ -0,0 +1,194 @@
+/* eslint-disable @typescript-eslint/ban-ts-comment */
+import { Injectable, NgZone } from '@angular/core';
+import { Observable, asyncScheduler, queueScheduler } from 'rxjs';
+import { observeOn, subscribeOn, tap } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+// eslint-disable-next-line @typescript-eslint/no-empty-function
+function noop() {
+}
+/**
+ * Schedules tasks so that they are invoked inside the Zone that is passed in the constructor.
+ */
+export class ɵZoneScheduler {
+    zone;
+    delegate;
+    constructor(zone, delegate = queueScheduler) {
+        this.zone = zone;
+        this.delegate = delegate;
+    }
+    now() {
+        return this.delegate.now();
+    }
+    schedule(work, delay, state) {
+        const targetZone = this.zone;
+        // Wrap the specified work function to make sure that if nested scheduling takes place the
+        // work is executed in the correct zone
+        const workInZone = function (state) {
+            targetZone.runGuarded(() => {
+                work.apply(this, [state]);
+            });
+        };
+        // Scheduling itself needs to be run in zone to ensure setInterval calls for async scheduling are done
+        // inside the correct zone. This scheduler needs to schedule asynchronously always to ensure that
+        // firebase emissions are never synchronous. Specifying a delay causes issues with the queueScheduler delegate.
+        return this.delegate.schedule(workInZone, delay, state);
+    }
+}
+class BlockUntilFirstOperator {
+    zone;
+    // @ts-ignore
+    task = null;
+    constructor(zone) {
+        this.zone = zone;
+    }
+    call(subscriber, source) {
+        const unscheduleTask = this.unscheduleTask.bind(this);
+        // @ts-ignore
+        this.task = this.zone.run(() => Zone.current.scheduleMacroTask('firebaseZoneBlock', noop, {}, noop, noop));
+        return source.pipe(tap({ next: unscheduleTask, complete: unscheduleTask, error: unscheduleTask })).subscribe(subscriber).add(unscheduleTask);
+    }
+    unscheduleTask() {
+        // maybe this is a race condition, invoke in a timeout
+        // hold for 10ms while I try to figure out what is going on
+        setTimeout(() => {
+            if (this.task != null && this.task.state === 'scheduled') {
+                this.task.invoke();
+                this.task = null;
+            }
+        }, 10);
+    }
+}
+export class ɵAngularFireSchedulers {
+    ngZone;
+    outsideAngular;
+    insideAngular;
+    constructor(ngZone) {
+        this.ngZone = ngZone;
+        // @ts-ignore
+        this.outsideAngular = ngZone.runOutsideAngular(() => new ɵZoneScheduler(Zone.current));
+        // @ts-ignore
+        this.insideAngular = ngZone.run(() => new ɵZoneScheduler(Zone.current, asyncScheduler));
+        globalThis.ɵAngularFireScheduler ||= this;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.10", ngImport: i0, type: ɵAngularFireSchedulers, deps: [{ token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.10", ngImport: i0, type: ɵAngularFireSchedulers, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.10", ngImport: i0, type: ɵAngularFireSchedulers, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i0.NgZone }]; } });
+function getSchedulers() {
+    const schedulers = globalThis.ɵAngularFireScheduler;
+    if (!schedulers) {
+        throw new Error(`Either AngularFireModule has not been provided in your AppModule (this can be done manually or implictly using
+provideFirebaseApp) or you're calling an AngularFire method outside of an NgModule (which is not supported).`);
+    }
+    return schedulers;
+}
+function runOutsideAngular(fn) {
+    return getSchedulers().ngZone.runOutsideAngular(() => fn());
+}
+function run(fn) {
+    return getSchedulers().ngZone.run(() => fn());
+}
+export function observeOutsideAngular(obs$) {
+    return obs$.pipe(observeOn(getSchedulers().outsideAngular));
+}
+export function observeInsideAngular(obs$) {
+    return obs$.pipe(observeOn(getSchedulers().insideAngular));
+}
+export function keepUnstableUntilFirst(obs$) {
+    return ɵkeepUnstableUntilFirstFactory(getSchedulers())(obs$);
+}
+/**
+ * Operator to block the zone until the first value has been emitted or the observable
+ * has completed/errored. This is used to make sure that universal waits until the first
+ * value from firebase but doesn't block the zone forever since the firebase subscription
+ * is still alive.
+ */
+export function ɵkeepUnstableUntilFirstFactory(schedulers) {
+    return function keepUnstableUntilFirst(obs$) {
+        obs$ = obs$.lift(new BlockUntilFirstOperator(schedulers.ngZone));
+        return obs$.pipe(
+        // Run the subscribe body outside of Angular (e.g. calling Firebase SDK to add a listener to a change event)
+        subscribeOn(schedulers.outsideAngular), 
+        // Run operators inside the angular zone (e.g. side effects via tap())
+        observeOn(schedulers.insideAngular)
+        // INVESTIGATE https://github.com/angular/angularfire/pull/2315
+        // share()
+        );
+    };
+}
+// @ts-ignore
+const zoneWrapFn = (it, macrotask) => {
+    // eslint-disable-next-line @typescript-eslint/no-this-alias
+    const _this = this;
+    // function() is needed for the arguments object
+    return function () {
+        const _arguments = arguments;
+        if (macrotask) {
+            setTimeout(() => {
+                if (macrotask.state === 'scheduled') {
+                    macrotask.invoke();
+                }
+            }, 10);
+        }
+        return run(() => it.apply(_this, _arguments));
+    };
+};
+export const ɵzoneWrap = (it, blockUntilFirst) => {
+    // function() is needed for the arguments object
+    return function () {
+        // @ts-ignore
+        let macrotask;
+        const _arguments = arguments;
+        // if this is a callback function, e.g, onSnapshot, we should create a microtask and invoke 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) {
+                    // @ts-ignore
+                    macrotask ||= run(() => Zone.current.scheduleMacroTask('firebaseZoneBlock', noop, {}, noop, noop));
+                }
+                // TODO create a microtask to track callback functions
+                _arguments[i] = zoneWrapFn(_arguments[i], macrotask);
+            }
+        }
+        const ret = runOutsideAngular(() => it.apply(this, _arguments));
+        if (!blockUntilFirst) {
+            if (ret instanceof Observable) {
+                const schedulers = getSchedulers();
+                return ret.pipe(subscribeOn(schedulers.outsideAngular), observeOn(schedulers.insideAngular));
+            }
+            else {
+                return run(() => ret);
+            }
+        }
+        if (ret instanceof Observable) {
+            return ret.pipe(keepUnstableUntilFirst);
+        }
+        else if (ret instanceof Promise) {
+            // eslint-disable-next-line @typescript-eslint/no-misused-promises
+            return run(() => new Promise((resolve, reject) => ret.then(it => run(() => resolve(it)), reason => run(() => reject(reason)))));
+        }
+        else if (typeof ret === 'function' && macrotask) {
+            // Handle unsubscribe
+            // function() is needed for the arguments object
+            return function () {
+                setTimeout(() => {
+                    if (macrotask && macrotask.state === 'scheduled') {
+                        macrotask.invoke();
+                    }
+                }, 10);
+                return ret.apply(this, arguments);
+            };
+        }
+        else {
+            // TODO how do we handle storage uploads in Zone? and other stuff with cancel() etc?
+            return run(() => ret);
+        }
+    };
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"zones.js","sourceRoot":"","sources":["../../../src/zones.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable @typescript-eslint/ban-ts-comment */\nimport { Injectable, NgZone } from '@angular/core';\nimport {\n  Observable,\n  Operator,\n  SchedulerAction,\n  SchedulerLike,\n  Subscriber,\n  Subscription,\n  TeardownLogic,\n  asyncScheduler,\n  queueScheduler\n} from 'rxjs';\nimport { observeOn, subscribeOn, tap } from 'rxjs/operators';\n\n// eslint-disable-next-line @typescript-eslint/no-empty-function\nfunction noop() {\n}\n\n/**\n * Schedules tasks so that they are invoked inside the Zone that is passed in the constructor.\n */\nexport class ɵZoneScheduler implements SchedulerLike {\n  constructor(private zone: any, private delegate: any = queueScheduler) {\n  }\n\n  now() {\n    return this.delegate.now();\n  }\n\n  schedule(work: (this: SchedulerAction<any>, state?: any) => void, delay?: number, state?: any): Subscription {\n    const targetZone = this.zone;\n    // Wrap the specified work function to make sure that if nested scheduling takes place the\n    // work is executed in the correct zone\n    const workInZone = function(this: SchedulerAction<any>, state: any) {\n      targetZone.runGuarded(() => {\n        work.apply(this, [state]);\n      });\n    };\n\n    // Scheduling itself needs to be run in zone to ensure setInterval calls for async scheduling are done\n    // inside the correct zone. This scheduler needs to schedule asynchronously always to ensure that\n    // firebase emissions are never synchronous. Specifying a delay causes issues with the queueScheduler delegate.\n    return this.delegate.schedule(workInZone, delay, state);\n  }\n}\n\nclass BlockUntilFirstOperator<T> implements Operator<T, T> {\n  // @ts-ignore\n  private task: MacroTask | null = null;\n\n  constructor(private zone: any) {\n  }\n\n  call(subscriber: Subscriber<T>, source: Observable<T>): TeardownLogic {\n    const unscheduleTask = this.unscheduleTask.bind(this);\n    // @ts-ignore\n    this.task = this.zone.run(() => Zone.current.scheduleMacroTask('firebaseZoneBlock', noop, {}, noop, noop));\n\n    return source.pipe(\n      tap({ next: unscheduleTask, complete: unscheduleTask, error: unscheduleTask })\n    ).subscribe(subscriber).add(unscheduleTask);\n  }\n\n  private unscheduleTask() {\n    // maybe this is a race condition, invoke in a timeout\n    // hold for 10ms while I try to figure out what is going on\n    setTimeout(() => {\n      if (this.task != null && this.task.state === 'scheduled') {\n        this.task.invoke();\n        this.task = null;\n      }\n    }, 10);\n  }\n}\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class ɵAngularFireSchedulers {\n  public readonly outsideAngular: ɵZoneScheduler;\n  public readonly insideAngular: ɵZoneScheduler;\n\n  constructor(public ngZone: NgZone) {\n    // @ts-ignore\n    this.outsideAngular = ngZone.runOutsideAngular(() => new ɵZoneScheduler(Zone.current));\n    // @ts-ignore\n    this.insideAngular = ngZone.run(() => new ɵZoneScheduler(Zone.current, asyncScheduler));\n    globalThis.ɵAngularFireScheduler ||= this;\n  }\n}\n\nfunction getSchedulers() {\n  const schedulers = globalThis.ɵAngularFireScheduler as ɵAngularFireSchedulers|undefined;\n  if (!schedulers) {\n    throw new Error(\n`Either AngularFireModule has not been provided in your AppModule (this can be done manually or implictly using\nprovideFirebaseApp) or you're calling an AngularFire method outside of an NgModule (which is not supported).`);\n  }\n  return schedulers;\n}\n\nfunction runOutsideAngular<T>(fn: (...args: any[]) => T): T {\n  return getSchedulers().ngZone.runOutsideAngular(() => fn());\n}\n\nfunction run<T>(fn: (...args: any[]) => T): T {\n  return getSchedulers().ngZone.run(() => fn());\n}\n\nexport function observeOutsideAngular<T>(obs$: Observable<T>): Observable<T> {\n  return obs$.pipe(observeOn(getSchedulers().outsideAngular));\n}\n\nexport function observeInsideAngular<T>(obs$: Observable<T>): Observable<T> {\n  return obs$.pipe(observeOn(getSchedulers().insideAngular));\n}\n\nexport function keepUnstableUntilFirst<T>(obs$: Observable<T>): Observable<T> {\n  return ɵkeepUnstableUntilFirstFactory(getSchedulers())(obs$);\n}\n\n/**\n * Operator to block the zone until the first value has been emitted or the observable\n * has completed/errored. This is used to make sure that universal waits until the first\n * value from firebase but doesn't block the zone forever since the firebase subscription\n * is still alive.\n */\nexport function ɵkeepUnstableUntilFirstFactory(schedulers: ɵAngularFireSchedulers) {\n  return function keepUnstableUntilFirst<T>(obs$: Observable<T>): Observable<T> {\n    obs$ = obs$.lift(\n      new BlockUntilFirstOperator(schedulers.ngZone)\n    );\n\n    return obs$.pipe(\n      // Run the subscribe body outside of Angular (e.g. calling Firebase SDK to add a listener to a change event)\n      subscribeOn(schedulers.outsideAngular),\n      // Run operators inside the angular zone (e.g. side effects via tap())\n      observeOn(schedulers.insideAngular)\n      // INVESTIGATE https://github.com/angular/angularfire/pull/2315\n      // share()\n    );\n  };\n}\n\n// @ts-ignore\nconst zoneWrapFn = (it: (...args: any[]) => any, macrotask: MacroTask|undefined) => {\n  // eslint-disable-next-line @typescript-eslint/no-this-alias\n  const _this = this;\n  // function() is needed for the arguments object\n  return function() {\n    const _arguments = arguments;\n    if (macrotask) {\n      setTimeout(() => {\n        if (macrotask.state === 'scheduled') {\n          macrotask.invoke();\n        }\n      }, 10);\n    }\n    return run(() => it.apply(_this, _arguments));\n  };\n};\n\nexport const ɵzoneWrap = <T= unknown>(it: T, blockUntilFirst: boolean): T => {\n  // function() is needed for the arguments object\n  return function() {\n    // @ts-ignore\n    let macrotask: MacroTask | undefined;\n    const _arguments = arguments;\n    // if this is a callback function, e.g, onSnapshot, we should create a microtask and invoke it\n    // only once one of the callback functions is tripped.\n    for (let i = 0; i < arguments.length; i++) {\n      if (typeof _arguments[i] === 'function') {\n        if (blockUntilFirst) {\n          // @ts-ignore\n          macrotask ||= run(() => Zone.current.scheduleMacroTask('firebaseZoneBlock', noop, {}, noop, noop));\n        }\n        // TODO create a microtask to track callback functions\n        _arguments[i] = zoneWrapFn(_arguments[i], macrotask);\n      }\n    }\n    const ret = runOutsideAngular(() => (it as any).apply(this, _arguments));\n    if (!blockUntilFirst) {\n      if (ret instanceof Observable) {\n        const schedulers = getSchedulers();\n        return ret.pipe(\n          subscribeOn(schedulers.outsideAngular),\n          observeOn(schedulers.insideAngular),\n        );\n      } else {\n        return run(() => ret);\n      }\n    }\n    if (ret instanceof Observable) {\n      return ret.pipe(keepUnstableUntilFirst) as any;\n    } else if (ret instanceof Promise) {\n      // eslint-disable-next-line @typescript-eslint/no-misused-promises\n      return run(() => new Promise((resolve, reject) => ret.then(it => run(() => resolve(it)), reason => run(() => reject(reason)))));\n    } else if (typeof ret === 'function' && macrotask) {\n      // Handle unsubscribe\n      // function() is needed for the arguments object\n      return function() {\n        setTimeout(() => {\n          if (macrotask && macrotask.state === 'scheduled') {\n            macrotask.invoke();\n          }\n        }, 10);\n        return ret.apply(this, arguments);\n      };\n    } else {\n      // TODO how do we handle storage uploads in Zone? and other stuff with cancel() etc?\n      return run(() => ret);\n    }\n  } as any;\n};\n"]}