@angular/fire 7.6.1 → 16.0.0-canary.5793d6f

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

@@ -0,0 +1,206 @@
+import { Inject, Injectable, InjectionToken, NgZone, Optional, PLATFORM_ID } from '@angular/core';
+import { keepUnstableUntilFirst, ɵAngularFireSchedulers } from '@angular/fire';
+import { ɵapplyMixins, ɵlazySDKProxy } from '@angular/fire/compat';
+import { FIREBASE_APP_NAME, FIREBASE_OPTIONS, ɵcacheInstance, ɵfirebaseAppFactory } from '@angular/fire/compat';
+import { isSupported } from 'firebase/remote-config';
+import { EMPTY, Observable, concat, of, pipe } from 'rxjs';
+import { debounceTime, distinctUntilChanged, filter, groupBy, map, mergeMap, observeOn, scan, shareReplay, startWith, switchMap, withLatestFrom } from 'rxjs/operators';
+import { proxyPolyfillCompat } from './base';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/fire";
+export const SETTINGS = new InjectionToken('angularfire2.remoteConfig.settings');
+export const DEFAULTS = new InjectionToken('angularfire2.remoteConfig.defaultConfig');
+const AS_TO_FN = { strings: 'asString', numbers: 'asNumber', booleans: 'asBoolean' };
+const STATIC_VALUES = { numbers: 0, booleans: false, strings: undefined };
+// TODO look into the types here, I don't like the anys
+const proxyAll = (observable, as) => new Proxy(observable.pipe(mapToObject(as)), {
+    get: (self, name) => self[name] || observable.pipe(map(all => all.find(p => p.key === name)), map(param => param ? param[AS_TO_FN[as]]() : STATIC_VALUES[as]), distinctUntilChanged())
+});
+// TODO export as implements Partial<...> so minor doesn't break us
+export class Value {
+    _source;
+    _value;
+    asBoolean() {
+        return ['1', 'true', 't', 'y', 'yes', 'on'].indexOf(this._value.toLowerCase()) > -1;
+    }
+    asString() {
+        return this._value;
+    }
+    asNumber() {
+        return Number(this._value) || 0;
+    }
+    getSource() {
+        return this._source;
+    }
+    constructor(_source, _value) {
+        this._source = _source;
+        this._value = _value;
+    }
+}
+// SEMVER use ConstructorParameters when we can support Typescript 3.6
+export class Parameter extends Value {
+    key;
+    fetchTimeMillis;
+    constructor(key, fetchTimeMillis, source, value) {
+        super(source, value);
+        this.key = key;
+        this.fetchTimeMillis = fetchTimeMillis;
+    }
+}
+// If it's a Parameter array, test any, else test the individual Parameter
+const filterTest = (fn) => filter(it => Array.isArray(it) ? it.some(fn) : fn(it));
+// Allow the user to bypass the default values and wait till they get something from the server, even if it's a cached copy;
+// if used in conjuntion with first() it will only fetch RC values from the server if they aren't cached locally
+export const filterRemote = () => filterTest(p => p.getSource() === 'remote');
+// filterFresh allows the developer to effectively set up a maximum cache time
+export const filterFresh = (howRecentInMillis) => filterTest(p => p.fetchTimeMillis + howRecentInMillis >= new Date().getTime());
+// I ditched loading the defaults into RC and a simple map for scan since we already have our own defaults implementation.
+// The idea here being that if they have a default that never loads from the server, they will be able to tell via fetchTimeMillis
+// on the Parameter. Also if it doesn't come from the server it won't emit again in .changes, due to the distinctUntilChanged,
+// which we can simplify to === rather than deep comparison
+const scanToParametersArray = (remoteConfig) => pipe(withLatestFrom(remoteConfig), scan((existing, [all, rc]) => {
+    // SEMVER use "new Set" to unique once we're only targeting es6
+    // at the scale we expect remote config to be at, we probably won't see a performance hit from this unoptimized uniqueness
+    // implementation.
+    // const allKeys = [...new Set([...existing.map(p => p.key), ...Object.keys(all)])];
+    const allKeys = [...existing.map(p => p.key), ...Object.keys(all)].filter((v, i, a) => a.indexOf(v) === i);
+    return allKeys.map(key => {
+        const updatedValue = all[key];
+        return updatedValue ? new Parameter(key, rc ? rc.fetchTimeMillis : -1, updatedValue.getSource(), updatedValue.asString())
+            : existing.find(p => p.key === key);
+    });
+}, []));
+export class AngularFireRemoteConfig {
+    zone;
+    changes;
+    parameters;
+    numbers;
+    booleans;
+    strings;
+    constructor(options, name, settings, defaultConfig, zone, schedulers, 
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars,@typescript-eslint/ban-types
+    platformId) {
+        this.zone = zone;
+        const remoteConfig$ = of(undefined).pipe(observeOn(schedulers.outsideAngular), switchMap(() => isSupported()), switchMap(isSupported => isSupported ? import('firebase/compat/remote-config') : EMPTY), map(() => ɵfirebaseAppFactory(options, zone, name)), map(app => ɵcacheInstance(`${app.name}.remote-config`, 'AngularFireRemoteConfig', app.name, () => {
+            const rc = app.remoteConfig();
+            if (settings) {
+                rc.settings = settings;
+            }
+            if (defaultConfig) {
+                rc.defaultConfig = defaultConfig;
+            }
+            return rc;
+        }, [settings, defaultConfig])), startWith(undefined), shareReplay({ bufferSize: 1, refCount: false }));
+        const loadedRemoteConfig$ = remoteConfig$.pipe(filter(rc => !!rc));
+        const default$ = of(Object.keys(defaultConfig || {}).reduce((c, k) => ({ ...c, [k]: new Value('default', defaultConfig[k].toString()) }), {}));
+        // we should filter out the defaults we provided to RC, since we have our own implementation
+        // that gives us a -1 for fetchTimeMillis (so filterFresh can filter them out)
+        const filterOutDefaults = map(all => Object.keys(all)
+            .filter(key => all[key].getSource() !== 'default')
+            .reduce((acc, key) => ({ ...acc, [key]: all[key] }), {}));
+        const existing$ = loadedRemoteConfig$.pipe(switchMap(rc => rc.activate()
+            .then(() => rc.ensureInitialized())
+            .then(() => rc.getAll())), filterOutDefaults);
+        const fresh$ = loadedRemoteConfig$.pipe(switchMap(rc => zone.runOutsideAngular(() => rc.fetchAndActivate()
+            .then(() => rc.ensureInitialized())
+            .then(() => rc.getAll()))), filterOutDefaults);
+        this.parameters = concat(default$, existing$, fresh$).pipe(scanToParametersArray(remoteConfig$), keepUnstableUntilFirst, shareReplay({ bufferSize: 1, refCount: true }));
+        this.changes = this.parameters.pipe(switchMap(params => of(...params)), groupBy(param => param.key), mergeMap(group => group.pipe(distinctUntilChanged())));
+        this.strings = proxyAll(this.parameters, 'strings');
+        this.booleans = proxyAll(this.parameters, 'booleans');
+        this.numbers = proxyAll(this.parameters, 'numbers');
+        return ɵlazySDKProxy(this, loadedRemoteConfig$, zone);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.3", ngImport: i0, type: AngularFireRemoteConfig, deps: [{ token: FIREBASE_OPTIONS }, { token: FIREBASE_APP_NAME, optional: true }, { token: SETTINGS, optional: true }, { token: DEFAULTS, optional: true }, { token: i0.NgZone }, { token: i1.ɵAngularFireSchedulers }, { token: PLATFORM_ID }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.1.3", ngImport: i0, type: AngularFireRemoteConfig, providedIn: 'any' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.3", ngImport: i0, type: AngularFireRemoteConfig, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'any'
+                }]
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [FIREBASE_OPTIONS]
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [FIREBASE_APP_NAME]
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [SETTINGS]
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [DEFAULTS]
+                }] }, { type: i0.NgZone }, { type: i1.ɵAngularFireSchedulers }, { type: Object, decorators: [{
+                    type: Inject,
+                    args: [PLATFORM_ID]
+                }] }]; } });
+export const budget = (interval) => (source) => new Observable(observer => {
+    let timedOut = false;
+    // TODO use scheduler task rather than settimeout
+    const timeout = setTimeout(() => {
+        observer.complete();
+        timedOut = true;
+    }, interval);
+    return source.subscribe({
+        next(val) {
+            if (!timedOut) {
+                observer.next(val);
+            }
+        },
+        error(err) {
+            if (!timedOut) {
+                clearTimeout(timeout);
+                observer.error(err);
+            }
+        },
+        complete() {
+            if (!timedOut) {
+                clearTimeout(timeout);
+                observer.complete();
+            }
+        }
+    });
+});
+const typedMethod = (it) => {
+    switch (typeof it) {
+        case 'string':
+            return 'asString';
+        case 'boolean':
+            return 'asBoolean';
+        case 'number':
+            return 'asNumber';
+        default:
+            return 'asString';
+    }
+};
+export function scanToObject(to = 'strings') {
+    return pipe(
+    // TODO cleanup
+    scan((c, p) => ({
+        ...c, [p.key]: typeof to === 'object' ?
+            p[typedMethod(to[p.key])]() :
+            p[AS_TO_FN[to]]()
+    }), typeof to === 'object' ?
+        to :
+        {}), debounceTime(1), budget(10), distinctUntilChanged((a, b) => JSON.stringify(a) === JSON.stringify(b)));
+}
+export function mapToObject(to = 'strings') {
+    return pipe(
+    // TODO this is getting a little long, cleanup
+    map((params) => params.reduce((c, p) => ({
+        ...c, [p.key]: typeof to === 'object' ?
+            p[typedMethod(to[p.key])]() :
+            p[AS_TO_FN[to]]()
+    }), typeof to === 'object' ?
+        to :
+        {})), distinctUntilChanged((a, b) => JSON.stringify(a) === JSON.stringify(b)));
+}
+ɵapplyMixins(AngularFireRemoteConfig, [proxyPolyfillCompat]);
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"remote-config.js","sourceRoot":"","sources":["../../../../../src/compat/remote-config/remote-config.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable, InjectionToken, NgZone, Optional, PLATFORM_ID } from '@angular/core';\nimport { keepUnstableUntilFirst, ɵAngularFireSchedulers } from '@angular/fire';\nimport { ɵPromiseProxy, ɵapplyMixins, ɵlazySDKProxy } from '@angular/fire/compat';\nimport { FIREBASE_APP_NAME, FIREBASE_OPTIONS, ɵcacheInstance, ɵfirebaseAppFactory } from '@angular/fire/compat';\nimport { FirebaseOptions } from 'firebase/app';\nimport firebase from 'firebase/compat/app';\nimport { isSupported } from 'firebase/remote-config';\nimport { EMPTY, MonoTypeOperatorFunction, Observable, OperatorFunction, concat, of, pipe } from 'rxjs';\nimport {\n  debounceTime,\n  distinctUntilChanged,\n  filter,\n  groupBy,\n  map,\n  mergeMap,\n  observeOn,\n  scan,\n  shareReplay,\n  startWith,\n  switchMap,\n  withLatestFrom\n} from 'rxjs/operators';\nimport { proxyPolyfillCompat } from './base';\nimport { Settings } from './interfaces';\n\nexport type ConfigTemplate = Record<string, string | number | boolean>;\n\nexport const SETTINGS = new InjectionToken<Settings>('angularfire2.remoteConfig.settings');\nexport const DEFAULTS = new InjectionToken<ConfigTemplate>('angularfire2.remoteConfig.defaultConfig');\n\n// eslint-disable-next-line @typescript-eslint/no-empty-interface\nexport interface AngularFireRemoteConfig extends ɵPromiseProxy<firebase.remoteConfig.RemoteConfig> {\n}\n\nconst AS_TO_FN = { strings: 'asString', numbers: 'asNumber', booleans: 'asBoolean' };\nconst STATIC_VALUES = { numbers: 0, booleans: false, strings: undefined };\n\n// TODO look into the types here, I don't like the anys\nconst proxyAll = (observable: Observable<Parameter[]>, as: 'numbers' | 'booleans' | 'strings') => new Proxy(\n  observable.pipe(mapToObject(as as any)), {\n    get: (self, name: string) => self[name] || observable.pipe(\n      map(all => all.find(p => p.key === name)),\n      map(param => param ? param[AS_TO_FN[as]]() : STATIC_VALUES[as]),\n      distinctUntilChanged()\n    )\n  }\n) as any;\n\n// TODO export as implements Partial<...> so minor doesn't break us\nexport class Value implements firebase.remoteConfig.Value {\n  asBoolean() {\n    return ['1', 'true', 't', 'y', 'yes', 'on'].indexOf(this._value.toLowerCase()) > -1;\n  }\n\n  asString() {\n    return this._value;\n  }\n\n  asNumber() {\n    return Number(this._value) || 0;\n  }\n\n  getSource() {\n    return this._source;\n  }\n\n  constructor(public _source: firebase.remoteConfig.ValueSource, public _value: string) {\n  }\n}\n\n// SEMVER use ConstructorParameters when we can support Typescript 3.6\nexport class Parameter extends Value {\n  constructor(public key: string, public fetchTimeMillis: number, source: firebase.remoteConfig.ValueSource, value: string) {\n    super(source, value);\n  }\n}\n\n// If it's a Parameter array, test any, else test the individual Parameter\nconst filterTest = (fn: (param: Parameter) => boolean) => filter<Parameter | Parameter[]>(it => Array.isArray(it) ? it.some(fn) : fn(it));\n\n// Allow the user to bypass the default values and wait till they get something from the server, even if it's a cached copy;\n// if used in conjuntion with first() it will only fetch RC values from the server if they aren't cached locally\nexport const filterRemote = () => filterTest(p => p.getSource() === 'remote');\n\n// filterFresh allows the developer to effectively set up a maximum cache time\nexport const filterFresh = (howRecentInMillis: number) => filterTest(p => p.fetchTimeMillis + howRecentInMillis >= new Date().getTime());\n\n\n// I ditched loading the defaults into RC and a simple map for scan since we already have our own defaults implementation.\n// The idea here being that if they have a default that never loads from the server, they will be able to tell via fetchTimeMillis\n// on the Parameter. Also if it doesn't come from the server it won't emit again in .changes, due to the distinctUntilChanged,\n// which we can simplify to === rather than deep comparison\nconst scanToParametersArray = (\n  remoteConfig: Observable<firebase.remoteConfig.RemoteConfig | undefined>\n): OperatorFunction<Record<string, firebase.remoteConfig.Value>, Parameter[]> => pipe(\n  withLatestFrom(remoteConfig),\n  scan((existing, [all, rc]) => {\n    // SEMVER use \"new Set\" to unique once we're only targeting es6\n    // at the scale we expect remote config to be at, we probably won't see a performance hit from this unoptimized uniqueness\n    // implementation.\n    // const allKeys = [...new Set([...existing.map(p => p.key), ...Object.keys(all)])];\n    const allKeys = [...existing.map(p => p.key), ...Object.keys(all)].filter((v, i, a) => a.indexOf(v) === i);\n    return allKeys.map(key => {\n      const updatedValue = all[key];\n      return updatedValue ? new Parameter(key, rc ? rc.fetchTimeMillis : -1, updatedValue.getSource(), updatedValue.asString())\n        : existing.find(p => p.key === key);\n    });\n  }, [] as Parameter[])\n);\n\n\n@Injectable({\n  providedIn: 'any'\n})\nexport class AngularFireRemoteConfig {\n\n  readonly changes: Observable<Parameter>;\n  readonly parameters: Observable<Parameter[]>;\n  readonly numbers: Observable<Record<string, number | undefined>> & Record<string, Observable<number>>;\n  readonly booleans: Observable<Record<string, boolean | undefined>> & Record<string, Observable<boolean>>;\n  readonly strings: Observable<Record<string, string | undefined>> & Record<string, Observable<string | undefined>>;\n\n  constructor(\n    @Inject(FIREBASE_OPTIONS) options: FirebaseOptions,\n    @Optional() @Inject(FIREBASE_APP_NAME) name: string | null | undefined,\n    @Optional() @Inject(SETTINGS) settings: Settings | null,\n    @Optional() @Inject(DEFAULTS) defaultConfig: ConfigTemplate | null,\n    private zone: NgZone,\n    schedulers: ɵAngularFireSchedulers,\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars,@typescript-eslint/ban-types\n    @Inject(PLATFORM_ID) platformId: Object\n  ) {\n    const remoteConfig$ = of(undefined).pipe(\n      observeOn(schedulers.outsideAngular),\n      switchMap(() => isSupported()),\n      switchMap(isSupported => isSupported ? import('firebase/compat/remote-config') : EMPTY),\n      map(() => ɵfirebaseAppFactory(options, zone, name)),\n      map(app => ɵcacheInstance(`${app.name}.remote-config`, 'AngularFireRemoteConfig', app.name, () => {\n        const rc = app.remoteConfig();\n        if (settings) {\n          rc.settings = settings;\n        }\n        if (defaultConfig) {\n          rc.defaultConfig = defaultConfig;\n        }\n        return rc;\n      }, [settings, defaultConfig])),\n      startWith<firebase.remoteConfig.RemoteConfig, undefined>(undefined),\n      shareReplay({ bufferSize: 1, refCount: false })\n    ) as Observable<any>;\n\n    const loadedRemoteConfig$ = remoteConfig$.pipe(\n      filter<firebase.remoteConfig.RemoteConfig>(rc => !!rc)\n    );\n\n    const default$: Observable<Record<string, firebase.remoteConfig.Value>> = of(Object.keys(defaultConfig || {}).reduce(\n      (c, k) => ({ ...c, [k]: new Value('default', defaultConfig[k].toString()) }), {}\n    ));\n\n    // we should filter out the defaults we provided to RC, since we have our own implementation\n    // that gives us a -1 for fetchTimeMillis (so filterFresh can filter them out)\n    const filterOutDefaults = map<Record<string, firebase.remoteConfig.Value>, Record<string, firebase.remoteConfig.Value>>(all =>\n      Object.keys(all)\n        .filter(key => all[key].getSource() !== 'default')\n        .reduce((acc, key) => ({ ...acc, [key]: all[key] }), {})\n    );\n\n    const existing$ = loadedRemoteConfig$.pipe(\n      switchMap(rc =>\n        rc.activate()\n          .then(() => rc.ensureInitialized())\n          .then(() => rc.getAll())\n      ),\n      filterOutDefaults\n    );\n\n    const fresh$ = loadedRemoteConfig$.pipe(\n      switchMap(rc => zone.runOutsideAngular(() =>\n        rc.fetchAndActivate()\n          .then(() => rc.ensureInitialized())\n          .then(() => rc.getAll())\n      )),\n      filterOutDefaults\n    );\n\n    this.parameters = concat(default$, existing$, fresh$).pipe(\n      scanToParametersArray(remoteConfig$),\n      keepUnstableUntilFirst,\n      shareReplay({ bufferSize: 1, refCount: true })\n    );\n\n    this.changes = this.parameters.pipe(\n      switchMap(params => of(...params)),\n      groupBy(param => param.key),\n      mergeMap(group => group.pipe(\n        distinctUntilChanged()\n      ))\n    );\n\n    this.strings = proxyAll(this.parameters, 'strings');\n    this.booleans = proxyAll(this.parameters, 'booleans');\n    this.numbers = proxyAll(this.parameters, 'numbers');\n\n    return ɵlazySDKProxy(this, loadedRemoteConfig$, zone);\n  }\n\n}\n\n\nexport const budget = <T>(interval: number): MonoTypeOperatorFunction<T> => (source: Observable<T>) => new Observable<T>(observer => {\n  let timedOut = false;\n  // TODO use scheduler task rather than settimeout\n  const timeout = setTimeout(() => {\n    observer.complete();\n    timedOut = true;\n  }, interval);\n  return source.subscribe({\n    next(val) {\n      if (!timedOut) {\n        observer.next(val);\n      }\n    },\n    error(err) {\n      if (!timedOut) {\n        clearTimeout(timeout);\n        observer.error(err);\n      }\n    },\n    complete() {\n      if (!timedOut) {\n        clearTimeout(timeout);\n        observer.complete();\n      }\n    }\n  });\n});\n\nconst typedMethod = (it: any) => {\n  switch (typeof it) {\n    case 'string':\n      return 'asString';\n    case 'boolean':\n      return 'asBoolean';\n    case 'number':\n      return 'asNumber';\n    default:\n      return 'asString';\n  }\n};\n\n\nexport function scanToObject(): OperatorFunction<Parameter, Record<string, string | undefined>>;\nexport function scanToObject(to: 'numbers'): OperatorFunction<Parameter, Record<string, number | undefined>>;\nexport function scanToObject(to: 'booleans'): OperatorFunction<Parameter, Record<string, boolean | undefined>>;\n// eslint-disable-next-line @typescript-eslint/unified-signatures\nexport function scanToObject(to: 'strings'): OperatorFunction<Parameter, Record<string, string | undefined>>;\nexport function scanToObject<T extends ConfigTemplate>(template: T): OperatorFunction<Parameter, T & Record<string, string | undefined>>;\nexport function scanToObject<T extends ConfigTemplate>(to: 'numbers' | 'booleans' | 'strings' | T = 'strings') {\n  return pipe(\n    // TODO cleanup\n    scan(\n      (c, p: Parameter) => ({\n        ...c, [p.key]: typeof to === 'object' ?\n          p[typedMethod(to[p.key])]() :\n          p[AS_TO_FN[to]]()\n      }),\n      typeof to === 'object' ?\n        to as T & Record<string, string | undefined> :\n        {} as Record<string, number | boolean | string>\n    ),\n    debounceTime(1),\n    budget(10),\n    distinctUntilChanged((a, b) => JSON.stringify(a) === JSON.stringify(b))\n  );\n}\n\nexport function mapToObject(): OperatorFunction<Parameter[], Record<string, string | undefined>>;\nexport function mapToObject(to: 'numbers'): OperatorFunction<Parameter[], Record<string, number | undefined>>;\nexport function mapToObject(to: 'booleans'): OperatorFunction<Parameter[], Record<string, boolean | undefined>>;\n// eslint-disable-next-line @typescript-eslint/unified-signatures\nexport function mapToObject(to: 'strings'): OperatorFunction<Parameter[], Record<string, string | undefined>>;\nexport function mapToObject<T extends ConfigTemplate>(template: T):\n  OperatorFunction<Parameter[], T & Record<string, string | undefined>>;\nexport function mapToObject<T extends ConfigTemplate>(to: 'numbers' | 'booleans' | 'strings' | T = 'strings') {\n  return pipe(\n    // TODO this is getting a little long, cleanup\n    map((params: Parameter[]) => params.reduce(\n      (c, p) => ({\n        ...c, [p.key]: typeof to === 'object' ?\n          p[typedMethod(to[p.key])]() :\n          p[AS_TO_FN[to]]()\n      }),\n      typeof to === 'object' ?\n        to as T & Record<string, string | undefined> :\n        {} as Record<string, number | boolean | string>\n    )),\n    distinctUntilChanged((a, b) => JSON.stringify(a) === JSON.stringify(b))\n  );\n}\n\nɵapplyMixins(AngularFireRemoteConfig, [proxyPolyfillCompat]);\n"]}

package/{esm2015/compat/remote-config/remote-config.module.js → esm2022/compat/remote-config/remote-config.module.mjs}

@@ -1,20 +1,20 @@
 import { NgModule } from '@angular/core';
-import { AngularFireRemoteConfig } from './remote-config';
-import firebase from 'firebase/compat/app';
 import { VERSION } from '@angular/fire';
+import firebase from 'firebase/compat/app';
+import { AngularFireRemoteConfig } from './remote-config';
 import * as i0 from "@angular/core";
 export class AngularFireRemoteConfigModule {
     constructor() {
         firebase.registerVersion('angularfire', VERSION.full, 'rc-compat');
     }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.3", ngImport: i0, type: AngularFireRemoteConfigModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.1.3", ngImport: i0, type: AngularFireRemoteConfigModule });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.1.3", ngImport: i0, type: AngularFireRemoteConfigModule, providers: [AngularFireRemoteConfig] });
 }
-AngularFireRemoteConfigModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.1.3", ngImport: i0, type: AngularFireRemoteConfigModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-AngularFireRemoteConfigModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "12.1.3", ngImport: i0, type: AngularFireRemoteConfigModule });
-AngularFireRemoteConfigModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "12.1.3", ngImport: i0, type: AngularFireRemoteConfigModule, providers: [AngularFireRemoteConfig] });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.1.3", ngImport: i0, type: AngularFireRemoteConfigModule, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.3", ngImport: i0, type: AngularFireRemoteConfigModule, decorators: [{
             type: NgModule,
             args: [{
                     providers: [AngularFireRemoteConfig]
                 }]
         }], ctorParameters: function () { return []; } });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVtb3RlLWNvbmZpZy5tb2R1bGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvY29tcGF0L3JlbW90ZS1jb25maWcvcmVtb3RlLWNvbmZpZy5tb2R1bGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUN6QyxPQUFPLEVBQUUsdUJBQXVCLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQztBQUMxRCxPQUFPLFFBQVEsTUFBTSxxQkFBcUIsQ0FBQztBQUMzQyxPQUFPLEVBQUUsT0FBTyxFQUFFLE1BQU0sZUFBZSxDQUFDOztBQUt4QyxNQUFNLE9BQU8sNkJBQTZCO0lBQ3RDO1FBQ0ksUUFBUSxDQUFDLGVBQWUsQ0FBQyxhQUFhLEVBQUUsT0FBTyxDQUFDLElBQUksRUFBRSxXQUFXLENBQUMsQ0FBQztJQUN2RSxDQUFDOzswSEFIUSw2QkFBNkI7MkhBQTdCLDZCQUE2QjsySEFBN0IsNkJBQTZCLGFBRjdCLENBQUUsdUJBQXVCLENBQUU7MkZBRTNCLDZCQUE2QjtrQkFIekMsUUFBUTttQkFBQztvQkFDUixTQUFTLEVBQUUsQ0FBRSx1QkFBdUIsQ0FBRTtpQkFDdkMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBOZ01vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgQW5ndWxhckZpcmVSZW1vdGVDb25maWcgfSBmcm9tICcuL3JlbW90ZS1jb25maWcnO1xuaW1wb3J0IGZpcmViYXNlIGZyb20gJ2ZpcmViYXNlL2NvbXBhdC9hcHAnO1xuaW1wb3J0IHsgVkVSU0lPTiB9IGZyb20gJ0Bhbmd1bGFyL2ZpcmUnO1xuXG5ATmdNb2R1bGUoe1xuICBwcm92aWRlcnM6IFsgQW5ndWxhckZpcmVSZW1vdGVDb25maWcgXVxufSlcbmV4cG9ydCBjbGFzcyBBbmd1bGFyRmlyZVJlbW90ZUNvbmZpZ01vZHVsZSB7XG4gICAgY29uc3RydWN0b3IoKSB7XG4gICAgICAgIGZpcmViYXNlLnJlZ2lzdGVyVmVyc2lvbignYW5ndWxhcmZpcmUnLCBWRVJTSU9OLmZ1bGwsICdyYy1jb21wYXQnKTtcbiAgICB9XG59XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVtb3RlLWNvbmZpZy5tb2R1bGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvY29tcGF0L3JlbW90ZS1jb25maWcvcmVtb3RlLWNvbmZpZy5tb2R1bGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUN6QyxPQUFPLEVBQUUsT0FBTyxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQ3hDLE9BQU8sUUFBUSxNQUFNLHFCQUFxQixDQUFDO0FBQzNDLE9BQU8sRUFBRSx1QkFBdUIsRUFBRSxNQUFNLGlCQUFpQixDQUFDOztBQUsxRCxNQUFNLE9BQU8sNkJBQTZCO0lBQ3RDO1FBQ0ksUUFBUSxDQUFDLGVBQWUsQ0FBQyxhQUFhLEVBQUUsT0FBTyxDQUFDLElBQUksRUFBRSxXQUFXLENBQUMsQ0FBQztJQUN2RSxDQUFDO3VHQUhRLDZCQUE2Qjt3R0FBN0IsNkJBQTZCO3dHQUE3Qiw2QkFBNkIsYUFGN0IsQ0FBRSx1QkFBdUIsQ0FBRTs7MkZBRTNCLDZCQUE2QjtrQkFIekMsUUFBUTttQkFBQztvQkFDUixTQUFTLEVBQUUsQ0FBRSx1QkFBdUIsQ0FBRTtpQkFDdkMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBOZ01vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgVkVSU0lPTiB9IGZyb20gJ0Bhbmd1bGFyL2ZpcmUnO1xuaW1wb3J0IGZpcmViYXNlIGZyb20gJ2ZpcmViYXNlL2NvbXBhdC9hcHAnO1xuaW1wb3J0IHsgQW5ndWxhckZpcmVSZW1vdGVDb25maWcgfSBmcm9tICcuL3JlbW90ZS1jb25maWcnO1xuXG5ATmdNb2R1bGUoe1xuICBwcm92aWRlcnM6IFsgQW5ndWxhckZpcmVSZW1vdGVDb25maWcgXVxufSlcbmV4cG9ydCBjbGFzcyBBbmd1bGFyRmlyZVJlbW90ZUNvbmZpZ01vZHVsZSB7XG4gICAgY29uc3RydWN0b3IoKSB7XG4gICAgICAgIGZpcmViYXNlLnJlZ2lzdGVyVmVyc2lvbignYW5ndWxhcmZpcmUnLCBWRVJTSU9OLmZ1bGwsICdyYy1jb21wYXQnKTtcbiAgICB9XG59XG4iXX0=

package/esm2022/compat/storage/observable/fromTask.mjs

@@ -0,0 +1,36 @@
+import { Observable } from 'rxjs';
+import { debounceTime } from 'rxjs/operators';
+// need to import, else the types become import('firebase/compat/app').default.storage.UploadTask
+// and it no longer works w/Firebase v7
+// Things aren't working great, I'm having to put in a lot of work-arounds for what
+// appear to be Firebase JS SDK bugs https://github.com/firebase/firebase-js-sdk/issues/4158
+export function fromTask(task) {
+    return new Observable(subscriber => {
+        const progress = (snap) => subscriber.next(snap);
+        const error = e => subscriber.error(e);
+        const complete = () => subscriber.complete();
+        // emit the current snapshot, so they don't have to wait for state_changes
+        // to fire next... this is stale if the task is no longer running :(
+        progress(task.snapshot);
+        const unsub = task.on('state_changed', progress);
+        // it turns out that neither task snapshot nor 'state_changed' fire the last
+        // snapshot before completion, the one with status 'success" and 100% progress
+        // so let's use the promise form of the task for that
+        task.then(snapshot => {
+            progress(snapshot);
+            complete();
+        }, e => {
+            // TODO investigate, again this is stale, we never fire a canceled or error it seems
+            progress(task.snapshot);
+            error(e);
+        });
+        // on's type if Function, rather than () => void, need to wrap
+        return function unsubscribe() {
+            unsub();
+        };
+    }).pipe(
+    // deal with sync emissions from first emitting `task.snapshot`, this makes sure
+    // that if the task is already finished we don't emit the old running state
+    debounceTime(0));
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/compat/storage/pipes/storageUrl.pipe.mjs

@@ -0,0 +1,58 @@
+import { AsyncPipe } from '@angular/common';
+import { ChangeDetectorRef, NgModule, Optional, Pipe } from '@angular/core';
+import { TransferState, makeStateKey } from '@angular/platform-browser';
+import { of } from 'rxjs';
+import { tap } from 'rxjs/operators';
+import { AngularFireStorage } from '../storage';
+import * as i0 from "@angular/core";
+import * as i1 from "../storage";
+import * as i2 from "@angular/platform-browser";
+/** to be used with in combination with | async */
+export class GetDownloadURLPipe {
+    storage;
+    state;
+    asyncPipe;
+    path;
+    downloadUrl$;
+    constructor(storage, cdr, state) {
+        this.storage = storage;
+        this.state = state;
+        this.asyncPipe = new AsyncPipe(cdr);
+    }
+    transform(path) {
+        if (path !== this.path) {
+            this.path = path;
+            const key = makeStateKey(`|getDownloadURL|${path}`);
+            const existing = this.state?.get(key, undefined);
+            this.downloadUrl$ = existing ? of(existing) : this.storage.ref(path).getDownloadURL().pipe(tap(it => this.state?.set(key, it)));
+        }
+        return this.asyncPipe.transform(this.downloadUrl$);
+    }
+    ngOnDestroy() {
+        this.asyncPipe.ngOnDestroy();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.3", ngImport: i0, type: GetDownloadURLPipe, deps: [{ token: i1.AngularFireStorage }, { token: i0.ChangeDetectorRef }, { token: i2.TransferState, optional: true }], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "16.1.3", ngImport: i0, type: GetDownloadURLPipe, name: "getDownloadURL", pure: false });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.3", ngImport: i0, type: GetDownloadURLPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'getDownloadURL',
+                    pure: false,
+                }]
+        }], ctorParameters: function () { return [{ type: i1.AngularFireStorage }, { type: i0.ChangeDetectorRef }, { type: i2.TransferState, decorators: [{
+                    type: Optional
+                }] }]; } });
+export class GetDownloadURLPipeModule {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.3", ngImport: i0, type: GetDownloadURLPipeModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.1.3", ngImport: i0, type: GetDownloadURLPipeModule, declarations: [GetDownloadURLPipe], exports: [GetDownloadURLPipe] });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.1.3", ngImport: i0, type: GetDownloadURLPipeModule });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.3", ngImport: i0, type: GetDownloadURLPipeModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [GetDownloadURLPipe],
+                    exports: [GetDownloadURLPipe],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -1,7 +1,7 @@
-import { createUploadTask } from './task';
+import { keepUnstableUntilFirst, observeOutsideAngular } from '@angular/fire';
 import { from, of } from 'rxjs';
-import { observeOutsideAngular, keepUnstableUntilFirst } from '@angular/fire';
 import { switchMap } from 'rxjs/operators';
+import { createUploadTask } from './task';
 /**
  * Create an AngularFire wrapped Storage Reference. This object
  * creates observable methods from promise based methods.
@@ -25,4 +25,4 @@ export function createStorageRef(ref) {
         listAll: () => from(ref.listAll())
     };
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/compat/storage/storage.mjs

@@ -0,0 +1,95 @@
+import { Inject, Injectable, InjectionToken, NgZone, Optional, PLATFORM_ID } from '@angular/core';
+import { ɵAngularFireSchedulers } from '@angular/fire';
+import { AppCheckInstances } from '@angular/fire/app-check';
+import { FIREBASE_APP_NAME, FIREBASE_OPTIONS, ɵcacheInstance, ɵfirebaseAppFactory } from '@angular/fire/compat';
+import { createStorageRef } from './ref';
+import 'firebase/compat/storage';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/fire";
+import * as i2 from "@angular/fire/app-check";
+export const BUCKET = new InjectionToken('angularfire2.storageBucket');
+export const MAX_UPLOAD_RETRY_TIME = new InjectionToken('angularfire2.storage.maxUploadRetryTime');
+export const MAX_OPERATION_RETRY_TIME = new InjectionToken('angularfire2.storage.maxOperationRetryTime');
+export const USE_EMULATOR = new InjectionToken('angularfire2.storage.use-emulator');
+/**
+ * AngularFireStorage Service
+ *
+ * This service is the main entry point for this feature module. It provides
+ * an API for uploading and downloading binary files from Cloud Storage for
+ * Firebase.
+ */
+export class AngularFireStorage {
+    storage;
+    constructor(options, name, storageBucket, 
+    // eslint-disable-next-line @typescript-eslint/ban-types
+    platformId, zone, schedulers, maxUploadRetryTime, maxOperationRetryTime, _useEmulator, _appCheckInstances) {
+        const app = ɵfirebaseAppFactory(options, zone, name);
+        this.storage = ɵcacheInstance(`${app.name}.storage.${storageBucket}`, 'AngularFireStorage', app.name, () => {
+            const storage = zone.runOutsideAngular(() => app.storage(storageBucket || undefined));
+            const useEmulator = _useEmulator;
+            if (useEmulator) {
+                storage.useEmulator(...useEmulator);
+            }
+            if (maxUploadRetryTime) {
+                storage.setMaxUploadRetryTime(maxUploadRetryTime);
+            }
+            if (maxOperationRetryTime) {
+                storage.setMaxOperationRetryTime(maxOperationRetryTime);
+            }
+            return storage;
+        }, [maxUploadRetryTime, maxOperationRetryTime]);
+    }
+    ref(path) {
+        return createStorageRef(this.storage.ref(path));
+    }
+    refFromURL(path) {
+        return createStorageRef(this.storage.refFromURL(path));
+    }
+    upload(path, data, metadata) {
+        const storageRef = this.storage.ref(path);
+        const ref = createStorageRef(storageRef);
+        return ref.put(data, metadata);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.3", ngImport: i0, type: AngularFireStorage, deps: [{ token: FIREBASE_OPTIONS }, { token: FIREBASE_APP_NAME, optional: true }, { token: BUCKET, optional: true }, { token: PLATFORM_ID }, { token: i0.NgZone }, { token: i1.ɵAngularFireSchedulers }, { token: MAX_UPLOAD_RETRY_TIME, optional: true }, { token: MAX_OPERATION_RETRY_TIME, optional: true }, { token: USE_EMULATOR, optional: true }, { token: i2.AppCheckInstances, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.1.3", ngImport: i0, type: AngularFireStorage, providedIn: 'any' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.3", ngImport: i0, type: AngularFireStorage, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'any'
+                }]
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [FIREBASE_OPTIONS]
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [FIREBASE_APP_NAME]
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [BUCKET]
+                }] }, { type: Object, decorators: [{
+                    type: Inject,
+                    args: [PLATFORM_ID]
+                }] }, { type: i0.NgZone }, { type: i1.ɵAngularFireSchedulers }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [MAX_UPLOAD_RETRY_TIME]
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [MAX_OPERATION_RETRY_TIME]
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [USE_EMULATOR]
+                }] }, { type: i2.AppCheckInstances, decorators: [{
+                    type: Optional
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/compat/storage/storage.module.mjs

@@ -0,0 +1,22 @@
+import { NgModule } from '@angular/core';
+import { VERSION } from '@angular/fire';
+import firebase from 'firebase/compat/app';
+import { GetDownloadURLPipeModule } from './pipes/storageUrl.pipe';
+import { AngularFireStorage } from './storage';
+import * as i0 from "@angular/core";
+export class AngularFireStorageModule {
+    constructor() {
+        firebase.registerVersion('angularfire', VERSION.full, 'gcs-compat');
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.3", ngImport: i0, type: AngularFireStorageModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.1.3", ngImport: i0, type: AngularFireStorageModule, exports: [GetDownloadURLPipeModule] });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.1.3", ngImport: i0, type: AngularFireStorageModule, providers: [AngularFireStorage], imports: [GetDownloadURLPipeModule] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.3", ngImport: i0, type: AngularFireStorageModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    exports: [GetDownloadURLPipeModule],
+                    providers: [AngularFireStorage]
+                }]
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RvcmFnZS5tb2R1bGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvY29tcGF0L3N0b3JhZ2Uvc3RvcmFnZS5tb2R1bGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUN6QyxPQUFPLEVBQUUsT0FBTyxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQ3hDLE9BQU8sUUFBUSxNQUFNLHFCQUFxQixDQUFDO0FBQzNDLE9BQU8sRUFBRSx3QkFBd0IsRUFBRSxNQUFNLHlCQUF5QixDQUFDO0FBQ25FLE9BQU8sRUFBRSxrQkFBa0IsRUFBRSxNQUFNLFdBQVcsQ0FBQzs7QUFNL0MsTUFBTSxPQUFPLHdCQUF3QjtJQUNuQztRQUNFLFFBQVEsQ0FBQyxlQUFlLENBQUMsYUFBYSxFQUFFLE9BQU8sQ0FBQyxJQUFJLEVBQUUsWUFBWSxDQUFDLENBQUM7SUFDdEUsQ0FBQzt1R0FIVSx3QkFBd0I7d0dBQXhCLHdCQUF3QixZQUh4Qix3QkFBd0I7d0dBR3hCLHdCQUF3QixhQUZ4QixDQUFFLGtCQUFrQixDQUFFLFlBRHRCLHdCQUF3Qjs7MkZBR3hCLHdCQUF3QjtrQkFKcEMsUUFBUTttQkFBQztvQkFDUixPQUFPLEVBQUUsQ0FBRSx3QkFBd0IsQ0FBRTtvQkFDckMsU0FBUyxFQUFFLENBQUUsa0JBQWtCLENBQUU7aUJBQ2xDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgTmdNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IFZFUlNJT04gfSBmcm9tICdAYW5ndWxhci9maXJlJztcbmltcG9ydCBmaXJlYmFzZSBmcm9tICdmaXJlYmFzZS9jb21wYXQvYXBwJztcbmltcG9ydCB7IEdldERvd25sb2FkVVJMUGlwZU1vZHVsZSB9IGZyb20gJy4vcGlwZXMvc3RvcmFnZVVybC5waXBlJztcbmltcG9ydCB7IEFuZ3VsYXJGaXJlU3RvcmFnZSB9IGZyb20gJy4vc3RvcmFnZSc7XG5cbkBOZ01vZHVsZSh7XG4gIGV4cG9ydHM6IFsgR2V0RG93bmxvYWRVUkxQaXBlTW9kdWxlIF0sXG4gIHByb3ZpZGVyczogWyBBbmd1bGFyRmlyZVN0b3JhZ2UgXVxufSlcbmV4cG9ydCBjbGFzcyBBbmd1bGFyRmlyZVN0b3JhZ2VNb2R1bGUge1xuICBjb25zdHJ1Y3RvcigpIHtcbiAgICBmaXJlYmFzZS5yZWdpc3RlclZlcnNpb24oJ2FuZ3VsYXJmaXJlJywgVkVSU0lPTi5mdWxsLCAnZ2NzLWNvbXBhdCcpO1xuICB9XG59XG4iXX0=

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

@@ -1,5 +1,5 @@
-import { fromTask } from './observable/fromTask';
 import { map } from 'rxjs/operators';
+import { fromTask } from './observable/fromTask';
 /**
  * Create an AngularFireUploadTask from a regular UploadTask from the Storage SDK.
  * This method creates an observable of the upload and returns on object that provides
@@ -18,4 +18,4 @@ export function createUploadTask(task) {
         percentageChanges: () => inner$.pipe(map(s => s.bytesTransferred / s.totalBytes * 100))
     };
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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