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

package/esm2022/compat/proxy.mjs

@@ -0,0 +1,58 @@
+// DEBUG quick debugger function for inline logging that typescript doesn't complain about
+//       wrote it for debugging the ɵlazySDKProxy, commenting out for now; should consider exposing a
+//       verbose mode for AngularFire in a future release that uses something like this in multiple places
+//       usage: () => log('something') || returnValue
+// const log = (...args: any[]): false => { console.log(...args); return false }
+// The problem here are things like ngOnDestroy are missing, then triggering the service
+// rather than dig too far; I'm capturing these as I go.
+const noopFunctions = ['ngOnDestroy'];
+// INVESTIGATE should we make the Proxy revokable and do some cleanup?
+//             right now it's fairly simple but I'm sure this will grow in complexity
+export const ɵlazySDKProxy = (klass, observable, zone, options = {}) => {
+    return new Proxy(klass, {
+        get: (_, name) => zone.runOutsideAngular(() => {
+            if (klass[name]) {
+                if (options?.spy?.get) {
+                    options.spy.get(name, klass[name]);
+                }
+                return klass[name];
+            }
+            if (noopFunctions.indexOf(name) > -1) {
+                return () => undefined;
+            }
+            const promise = observable.toPromise().then(mod => {
+                const ret = mod?.[name];
+                // TODO move to proper type guards
+                if (typeof ret === 'function') {
+                    return ret.bind(mod);
+                }
+                else if (ret?.then) {
+                    return ret.then((res) => zone.run(() => res));
+                }
+                else {
+                    return zone.run(() => ret);
+                }
+            });
+            // recurse the proxy
+            return new Proxy(() => undefined, {
+                get: (_, name) => promise[name],
+                // TODO handle callbacks as transparently as I can
+                apply: (self, _, args) => promise.then(it => {
+                    const res = it?.(...args);
+                    if (options?.spy?.apply) {
+                        options.spy.apply(name, args, res);
+                    }
+                    return res;
+                })
+            });
+        })
+    });
+};
+export const ɵapplyMixins = (derivedCtor, constructors) => {
+    constructors.forEach((baseCtor) => {
+        Object.getOwnPropertyNames(baseCtor.prototype || baseCtor).forEach((name) => {
+            Object.defineProperty(derivedCtor.prototype, name, Object.getOwnPropertyDescriptor(baseCtor.prototype || baseCtor, name));
+        });
+    });
+};
+//# sourceMappingURL=data:application/json;base64,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

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.2.10", 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.2.10", ngImport: i0, type: AngularFireRemoteConfig, providedIn: 'any' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.10", 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.2.10", ngImport: i0, type: AngularFireRemoteConfigModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.2.10", ngImport: i0, type: AngularFireRemoteConfigModule });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.2.10", 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.2.10", ngImport: i0, type: AngularFireRemoteConfigModule, decorators: [{
             type: NgModule,
             args: [{
                     providers: [AngularFireRemoteConfig]
                 }]
         }], ctorParameters: function () { return []; } });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVtb3RlLWNvbmZpZy5tb2R1bGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvY29tcGF0L3JlbW90ZS1jb25maWcvcmVtb3RlLWNvbmZpZy5tb2R1bGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUN6QyxPQUFPLEVBQUUsdUJBQXVCLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQztBQUMxRCxPQUFPLFFBQVEsTUFBTSxxQkFBcUIsQ0FBQztBQUMzQyxPQUFPLEVBQUUsT0FBTyxFQUFFLE1BQU0sZUFBZSxDQUFDOztBQUt4QyxNQUFNLE9BQU8sNkJBQTZCO0lBQ3RDO1FBQ0ksUUFBUSxDQUFDLGVBQWUsQ0FBQyxhQUFhLEVBQUUsT0FBTyxDQUFDLElBQUksRUFBRSxXQUFXLENBQUMsQ0FBQztJQUN2RSxDQUFDOzswSEFIUSw2QkFBNkI7MkhBQTdCLDZCQUE2QjsySEFBN0IsNkJBQTZCLGFBRjdCLENBQUUsdUJBQXVCLENBQUU7MkZBRTNCLDZCQUE2QjtrQkFIekMsUUFBUTttQkFBQztvQkFDUixTQUFTLEVBQUUsQ0FBRSx1QkFBdUIsQ0FBRTtpQkFDdkMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBOZ01vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgQW5ndWxhckZpcmVSZW1vdGVDb25maWcgfSBmcm9tICcuL3JlbW90ZS1jb25maWcnO1xuaW1wb3J0IGZpcmViYXNlIGZyb20gJ2ZpcmViYXNlL2NvbXBhdC9hcHAnO1xuaW1wb3J0IHsgVkVSU0lPTiB9IGZyb20gJ0Bhbmd1bGFyL2ZpcmUnO1xuXG5ATmdNb2R1bGUoe1xuICBwcm92aWRlcnM6IFsgQW5ndWxhckZpcmVSZW1vdGVDb25maWcgXVxufSlcbmV4cG9ydCBjbGFzcyBBbmd1bGFyRmlyZVJlbW90ZUNvbmZpZ01vZHVsZSB7XG4gICAgY29uc3RydWN0b3IoKSB7XG4gICAgICAgIGZpcmViYXNlLnJlZ2lzdGVyVmVyc2lvbignYW5ndWxhcmZpcmUnLCBWRVJTSU9OLmZ1bGwsICdyYy1jb21wYXQnKTtcbiAgICB9XG59XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVtb3RlLWNvbmZpZy5tb2R1bGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvY29tcGF0L3JlbW90ZS1jb25maWcvcmVtb3RlLWNvbmZpZy5tb2R1bGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUN6QyxPQUFPLEVBQUUsT0FBTyxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQ3hDLE9BQU8sUUFBUSxNQUFNLHFCQUFxQixDQUFDO0FBQzNDLE9BQU8sRUFBRSx1QkFBdUIsRUFBRSxNQUFNLGlCQUFpQixDQUFDOztBQUsxRCxNQUFNLE9BQU8sNkJBQTZCO0lBQ3RDO1FBQ0ksUUFBUSxDQUFDLGVBQWUsQ0FBQyxhQUFhLEVBQUUsT0FBTyxDQUFDLElBQUksRUFBRSxXQUFXLENBQUMsQ0FBQztJQUN2RSxDQUFDO3dHQUhRLDZCQUE2Qjt5R0FBN0IsNkJBQTZCO3lHQUE3Qiw2QkFBNkIsYUFGN0IsQ0FBRSx1QkFBdUIsQ0FBRTs7NEZBRTNCLDZCQUE2QjtrQkFIekMsUUFBUTttQkFBQztvQkFDUixTQUFTLEVBQUUsQ0FBRSx1QkFBdUIsQ0FBRTtpQkFDdkMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBOZ01vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgVkVSU0lPTiB9IGZyb20gJ0Bhbmd1bGFyL2ZpcmUnO1xuaW1wb3J0IGZpcmViYXNlIGZyb20gJ2ZpcmViYXNlL2NvbXBhdC9hcHAnO1xuaW1wb3J0IHsgQW5ndWxhckZpcmVSZW1vdGVDb25maWcgfSBmcm9tICcuL3JlbW90ZS1jb25maWcnO1xuXG5ATmdNb2R1bGUoe1xuICBwcm92aWRlcnM6IFsgQW5ndWxhckZpcmVSZW1vdGVDb25maWcgXVxufSlcbmV4cG9ydCBjbGFzcyBBbmd1bGFyRmlyZVJlbW90ZUNvbmZpZ01vZHVsZSB7XG4gICAgY29uc3RydWN0b3IoKSB7XG4gICAgICAgIGZpcmViYXNlLnJlZ2lzdGVyVmVyc2lvbignYW5ndWxhcmZpcmUnLCBWRVJTSU9OLmZ1bGwsICdyYy1jb21wYXQnKTtcbiAgICB9XG59XG4iXX0=

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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZnJvbVRhc2suanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9zcmMvY29tcGF0L3N0b3JhZ2Uvb2JzZXJ2YWJsZS9mcm9tVGFzay50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sTUFBTSxDQUFDO0FBQ2xDLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxnQkFBZ0IsQ0FBQztBQUc5QyxpR0FBaUc7QUFDakcsdUNBQXVDO0FBRXZDLG1GQUFtRjtBQUNuRiw0RkFBNEY7QUFDNUYsTUFBTSxVQUFVLFFBQVEsQ0FBQyxJQUFnQjtJQUN2QyxPQUFPLElBQUksVUFBVSxDQUFxQixVQUFVLENBQUMsRUFBRTtRQUNyRCxNQUFNLFFBQVEsR0FBRyxDQUFDLElBQXdCLEVBQUUsRUFBRSxDQUFDLFVBQVUsQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLENBQUM7UUFDckUsTUFBTSxLQUFLLEdBQUcsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxVQUFVLENBQUMsS0FBSyxDQUFDLENBQUMsQ0FBQyxDQUFDO1FBQ3ZDLE1BQU0sUUFBUSxHQUFHLEdBQUcsRUFBRSxDQUFDLFVBQVUsQ0FBQyxRQUFRLEVBQUUsQ0FBQztRQUM3QywwRUFBMEU7UUFDMUUsb0VBQW9FO1FBQ3BFLFFBQVEsQ0FBQyxJQUFJLENBQUMsUUFBUSxDQUFDLENBQUM7UUFDeEIsTUFBTSxLQUFLLEdBQUcsSUFBSSxDQUFDLEVBQUUsQ0FBQyxlQUFlLEVBQUUsUUFBUSxDQUFDLENBQUM7UUFDakQsNEVBQTRFO1FBQzVFLDhFQUE4RTtRQUM5RSxxREFBcUQ7UUFDckQsSUFBSSxDQUFDLElBQUksQ0FBQyxRQUFRLENBQUMsRUFBRTtZQUNuQixRQUFRLENBQUMsUUFBUSxDQUFDLENBQUM7WUFDbkIsUUFBUSxFQUFFLENBQUM7UUFDYixDQUFDLEVBQUUsQ0FBQyxDQUFDLEVBQUU7WUFDTCxvRkFBb0Y7WUFDcEYsUUFBUSxDQUFDLElBQUksQ0FBQyxRQUFRLENBQUMsQ0FBQztZQUN4QixLQUFLLENBQUMsQ0FBQyxDQUFDLENBQUM7UUFDWCxDQUFDLENBQUMsQ0FBQztRQUNILDhEQUE4RDtRQUM5RCxPQUFPLFNBQVMsV0FBVztZQUN6QixLQUFLLEVBQUUsQ0FBQztRQUNWLENBQUMsQ0FBQztJQUNKLENBQUMsQ0FBQyxDQUFDLElBQUk7SUFDTCxnRkFBZ0Y7SUFDaEYsMkVBQTJFO0lBQzNFLFlBQVksQ0FBQyxDQUFDLENBQUMsQ0FDaEIsQ0FBQztBQUNKLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBPYnNlcnZhYmxlIH0gZnJvbSAncnhqcyc7XG5pbXBvcnQgeyBkZWJvdW5jZVRpbWUgfSBmcm9tICdyeGpzL29wZXJhdG9ycyc7XG5pbXBvcnQgeyBVcGxvYWRUYXNrLCBVcGxvYWRUYXNrU25hcHNob3QgfSBmcm9tICcuLi9pbnRlcmZhY2VzJztcblxuLy8gbmVlZCB0byBpbXBvcnQsIGVsc2UgdGhlIHR5cGVzIGJlY29tZSBpbXBvcnQoJ2ZpcmViYXNlL2NvbXBhdC9hcHAnKS5kZWZhdWx0LnN0b3JhZ2UuVXBsb2FkVGFza1xuLy8gYW5kIGl0IG5vIGxvbmdlciB3b3JrcyB3L0ZpcmViYXNlIHY3XG5cbi8vIFRoaW5ncyBhcmVuJ3Qgd29ya2luZyBncmVhdCwgSSdtIGhhdmluZyB0byBwdXQgaW4gYSBsb3Qgb2Ygd29yay1hcm91bmRzIGZvciB3aGF0XG4vLyBhcHBlYXIgdG8gYmUgRmlyZWJhc2UgSlMgU0RLIGJ1Z3MgaHR0cHM6Ly9naXRodWIuY29tL2ZpcmViYXNlL2ZpcmViYXNlLWpzLXNkay9pc3N1ZXMvNDE1OFxuZXhwb3J0IGZ1bmN0aW9uIGZyb21UYXNrKHRhc2s6IFVwbG9hZFRhc2spIHtcbiAgcmV0dXJuIG5ldyBPYnNlcnZhYmxlPFVwbG9hZFRhc2tTbmFwc2hvdD4oc3Vic2NyaWJlciA9PiB7XG4gICAgY29uc3QgcHJvZ3Jlc3MgPSAoc25hcDogVXBsb2FkVGFza1NuYXBzaG90KSA9PiBzdWJzY3JpYmVyLm5leHQoc25hcCk7XG4gICAgY29uc3QgZXJyb3IgPSBlID0+IHN1YnNjcmliZXIuZXJyb3IoZSk7XG4gICAgY29uc3QgY29tcGxldGUgPSAoKSA9PiBzdWJzY3JpYmVyLmNvbXBsZXRlKCk7XG4gICAgLy8gZW1pdCB0aGUgY3VycmVudCBzbmFwc2hvdCwgc28gdGhleSBkb24ndCBoYXZlIHRvIHdhaXQgZm9yIHN0YXRlX2NoYW5nZXNcbiAgICAvLyB0byBmaXJlIG5leHQuLi4gdGhpcyBpcyBzdGFsZSBpZiB0aGUgdGFzayBpcyBubyBsb25nZXIgcnVubmluZyA6KFxuICAgIHByb2dyZXNzKHRhc2suc25hcHNob3QpO1xuICAgIGNvbnN0IHVuc3ViID0gdGFzay5vbignc3RhdGVfY2hhbmdlZCcsIHByb2dyZXNzKTtcbiAgICAvLyBpdCB0dXJucyBvdXQgdGhhdCBuZWl0aGVyIHRhc2sgc25hcHNob3Qgbm9yICdzdGF0ZV9jaGFuZ2VkJyBmaXJlIHRoZSBsYXN0XG4gICAgLy8gc25hcHNob3QgYmVmb3JlIGNvbXBsZXRpb24sIHRoZSBvbmUgd2l0aCBzdGF0dXMgJ3N1Y2Nlc3NcIiBhbmQgMTAwJSBwcm9ncmVzc1xuICAgIC8vIHNvIGxldCdzIHVzZSB0aGUgcHJvbWlzZSBmb3JtIG9mIHRoZSB0YXNrIGZvciB0aGF0XG4gICAgdGFzay50aGVuKHNuYXBzaG90ID0+IHtcbiAgICAgIHByb2dyZXNzKHNuYXBzaG90KTtcbiAgICAgIGNvbXBsZXRlKCk7XG4gICAgfSwgZSA9PiB7XG4gICAgICAvLyBUT0RPIGludmVzdGlnYXRlLCBhZ2FpbiB0aGlzIGlzIHN0YWxlLCB3ZSBuZXZlciBmaXJlIGEgY2FuY2VsZWQgb3IgZXJyb3IgaXQgc2VlbXNcbiAgICAgIHByb2dyZXNzKHRhc2suc25hcHNob3QpO1xuICAgICAgZXJyb3IoZSk7XG4gICAgfSk7XG4gICAgLy8gb24ncyB0eXBlIGlmIEZ1bmN0aW9uLCByYXRoZXIgdGhhbiAoKSA9PiB2b2lkLCBuZWVkIHRvIHdyYXBcbiAgICByZXR1cm4gZnVuY3Rpb24gdW5zdWJzY3JpYmUoKSB7XG4gICAgICB1bnN1YigpO1xuICAgIH07XG4gIH0pLnBpcGUoXG4gICAgLy8gZGVhbCB3aXRoIHN5bmMgZW1pc3Npb25zIGZyb20gZmlyc3QgZW1pdHRpbmcgYHRhc2suc25hcHNob3RgLCB0aGlzIG1ha2VzIHN1cmVcbiAgICAvLyB0aGF0IGlmIHRoZSB0YXNrIGlzIGFscmVhZHkgZmluaXNoZWQgd2UgZG9uJ3QgZW1pdCB0aGUgb2xkIHJ1bm5pbmcgc3RhdGVcbiAgICBkZWJvdW5jZVRpbWUoMClcbiAgKTtcbn1cbiJdfQ==

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.2.10", 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.2.10", ngImport: i0, type: GetDownloadURLPipe, name: "getDownloadURL", pure: false });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.10", 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.2.10", ngImport: i0, type: GetDownloadURLPipeModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.2.10", ngImport: i0, type: GetDownloadURLPipeModule, declarations: [GetDownloadURLPipe], exports: [GetDownloadURLPipe] });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.2.10", ngImport: i0, type: GetDownloadURLPipeModule });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.10", 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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