reactfire 4.0.0-exp.b6c8eeb → 4.0.0-exp.f654109

package/dist/{remote-config/index.d.ts → remote-config.d.ts}

@@ -1,35 +1,30 @@
-import { ObservableStatus } from '../useObservable';
-import { AllParameters } from './getValue';
+import { ObservableStatus } from './useObservable';
+import { AllParameters } from 'rxfire/remote-config';
 import type { Value as RemoteConfigValue } from 'firebase/remote-config';
 /**
  * Accepts a key and optionally a Remote Config instance. Returns a
  * Remote Config Value.
  *
  * @param key The parameter key in Remote Config
- * @param remoteConfig Optional instance. If not provided ReactFire will either grab the default instance or lazy load.
  */
 export declare function useRemoteConfigValue(key: string): ObservableStatus<RemoteConfigValue>;
 /**
  * Convience method similar to useRemoteConfigValue. Returns a `string` from a Remote Config parameter.
  * @param key The parameter key in Remote Config
- * @param remoteConfig Optional instance. If not provided ReactFire will either grab the default instance or lazy load.
  */
 export declare function useRemoteConfigString(key: string): ObservableStatus<string>;
 /**
  * Convience method similar to useRemoteConfigValue. Returns a `number` from a Remote Config parameter.
  * @param key The parameter key in Remote Config
- * @param remoteConfig Optional instance. If not provided ReactFire will either grab the default instance or lazy load.
  */
 export declare function useRemoteConfigNumber(key: string): ObservableStatus<number>;
 /**
  * Convience method similar to useRemoteConfigValue. Returns a `boolean` from a Remote Config parameter.
  * @param key The parameter key in Remote Config
- * @param remoteConfig Optional instance. If not provided ReactFire will either grab the default instance or lazy load.
  */
 export declare function useRemoteConfigBoolean(key: string): ObservableStatus<boolean>;
 /**
  * Convience method similar to useRemoteConfigValue. Returns allRemote Config parameters.
  * @param key The parameter key in Remote Config
- * @param remoteConfig Optional instance. If not provided ReactFire will either grab the default instance or lazy load.
  */
 export declare function useRemoteConfigAll(key: string): ObservableStatus<AllParameters>;

package/dist/sdk.d.ts

@@ -1,15 +1,29 @@
 import * as React from 'react';
+import type { AppCheck } from 'firebase/app-check';
 import type { Auth } from 'firebase/auth';
 import type { Analytics } from 'firebase/analytics';
 import type { Database } from 'firebase/database';
 import type { Firestore } from 'firebase/firestore';
+import type { Functions } from 'firebase/functions';
 import type { FirebasePerformance } from 'firebase/performance';
 import type { FirebaseStorage } from 'firebase/storage';
 import type { RemoteConfig } from 'firebase/remote-config';
 import { FirebaseApp } from 'firebase/app';
 import { ObservableStatus } from './useObservable';
 import { ReactFireOptions } from '.';
-declare type FirebaseSdks = Auth | Analytics | Database | Firestore | FirebasePerformance | FirebaseStorage | RemoteConfig;
+export declare const AppCheckSdkContext: React.Context<AppCheck | undefined>;
+export declare const AuthSdkContext: React.Context<Auth | undefined>;
+export declare const AnalyticsSdkContext: React.Context<Analytics | undefined>;
+export declare const DatabaseSdkContext: React.Context<Database | undefined>;
+export declare const FirestoreSdkContext: React.Context<Firestore | undefined>;
+export declare const FunctionsSdkContext: React.Context<Functions | undefined>;
+export declare const StorageSdkContext: React.Context<FirebaseStorage | undefined>;
+export declare const PerformanceSdkContext: React.Context<FirebasePerformance | undefined>;
+export declare const RemoteConfigSdkContext: React.Context<RemoteConfig | undefined>;
+declare type FirebaseSdks = Analytics | AppCheck | Auth | Database | Firestore | FirebasePerformance | FirebaseStorage | Functions | RemoteConfig;
+export declare const AppCheckProvider: (props: React.PropsWithChildren<{
+    sdk: AppCheck;
+}>) => JSX.Element;
 export declare const AuthProvider: (props: React.PropsWithChildren<{
     sdk: Auth;
 }>) => JSX.Element;
@@ -22,6 +36,9 @@ export declare const DatabaseProvider: (props: React.PropsWithChildren<{
 export declare const FirestoreProvider: (props: React.PropsWithChildren<{
     sdk: Firestore;
 }>) => JSX.Element;
+export declare const FunctionsProvider: (props: React.PropsWithChildren<{
+    sdk: Functions;
+}>) => JSX.Element;
 export declare const PerformanceProvider: (props: React.PropsWithChildren<{
     sdk: FirebasePerformance;
 }>) => JSX.Element;
@@ -31,18 +48,22 @@ export declare const StorageProvider: (props: React.PropsWithChildren<{
 export declare const RemoteConfigProvider: (props: React.PropsWithChildren<{
     sdk: RemoteConfig;
 }>) => JSX.Element;
+export declare const useAppCheck: () => AppCheck;
 export declare const useAuth: () => Auth;
 export declare const useAnalytics: () => Analytics;
 export declare const useDatabase: () => Database;
 export declare const useFirestore: () => Firestore;
+export declare const useFunctions: () => Functions;
 export declare const usePerformance: () => FirebasePerformance;
 export declare const useStorage: () => FirebaseStorage;
 export declare const useRemoteConfig: () => RemoteConfig;
 declare type InitSdkHook<Sdk extends FirebaseSdks> = (initializer: (firebaseApp: FirebaseApp) => Promise<Sdk>, options?: ReactFireOptions<Sdk>) => ObservableStatus<Sdk>;
+export declare const useInitAppCheck: InitSdkHook<AppCheck>;
 export declare const useInitAuth: InitSdkHook<Auth>;
 export declare const useInitAnalytics: InitSdkHook<Analytics>;
 export declare const useInitDatabase: InitSdkHook<Database>;
 export declare const useInitFirestore: InitSdkHook<Firestore>;
+export declare const useInitFunctions: InitSdkHook<Functions>;
 export declare const useInitPerformance: InitSdkHook<FirebasePerformance>;
 export declare const useInitRemoteConfig: InitSdkHook<RemoteConfig>;
 export declare const useInitStorage: InitSdkHook<FirebaseStorage>;

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "4.0.0-exp.b6c8eeb",
+  "version": "4.0.0-exp.f654109",
   "license": "MIT",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
@@ -14,16 +14,18 @@
     "start": "tsdx watch",
     "build": "tsdx build",
     "test:tsdx": "tsdx test",
-    "test": "firebase emulators:exec --only firestore,database,auth,storage --project=rxfire-525a3 \"tsdx test\"",
+    "test": "firebase emulators:exec --project=rxfire-525a3 \"tsdx test\"",
     "test:firestore": "firebase emulators:exec --only firestore --project=rxfire-525a3 \"tsdx test firestore --verbose\"",
     "test:database": "firebase emulators:exec --only database --project=rxfire-525a3 \"tsdx test database --verbose\"",
     "test:auth": "firebase emulators:exec --only auth --project=rxfire-525a3 \"tsdx test auth --verbose\"",
+    "test:functions": "firebase emulators:exec --only functions --project=rxfire-525a3 \"tsdx test functions --verbose\"",
     "test:storage": "firebase emulators:exec --only storage --project=rxfire-525a3 \"tsdx test storage --verbose\"",
     "test:useObservable": "tsdx test useObservable --verbose",
     "lint": "tsdx lint src test",
     "size": "size-limit",
     "analyze": "size-limit --why",
-    "docs": "typedoc --options typedoc.json && markdown-toc -i docs/use.md"
+    "docs": "typedoc --options typedoc.json && markdown-toc -i docs/use.md",
+    "docs:fork": "typedoc --options typedoc.json --gitRemote upstream && markdown-toc -i docs/use.md"
   },
   "peerDependencies": {
     "firebase": "^9.0.0",
@@ -81,7 +83,7 @@
     "babel-jest": "^26.6.3",
     "babel-plugin-minify-replace": "^0.5.0",
     "eslint-plugin-no-only-tests": "^2.6.0",
-    "firebase": "^9.0.0",
+    "firebase": "^9.0.1",
     "firebase-tools": "^9.16.0",
     "globalthis": "^1.0.1",
     "husky": "^4.3.0",
@@ -99,7 +101,7 @@
     "typescript": "^4.2.4"
   },
   "dependencies": {
-    "rxfire": "^6.0.0",
+    "rxfire": "^6.0.2",
     "rxjs": "^6.6.3 || ^7.0.1"
   },
   "resolutions": {

package/src/SuspenseSubject.ts

@@ -10,9 +10,9 @@ export class SuspenseSubject<T> extends Subject<T> {
   private _innerObservable: Observable<T>;
   private _warmupSubscription: Subscription;
 
-  // @ts-ignore: TODO: double check to see if this is an RXJS thing or if we should listen to TS
+  // @ts-expect-error: TODO: double check to see if this is an RXJS thing or if we should listen to TS
   private _innerSubscriber: Subscription;
-  // @ts-ignore: TODO: double check to see if this is an RXJS thing or if we should listen to TS
+  // @ts-expect-error: TODO: double check to see if this is an RXJS thing or if we should listen to TS
   private _resolveFirstEmission: () => void;
 
   constructor(innerObservable: Observable<T>, private _timeoutWindow: number) {
@@ -48,14 +48,16 @@ export class SuspenseSubject<T> extends Subject<T> {
     return this._hasValue || !!this._error;
   }
 
-  get value(): T | undefined {
+  get value(): T {
     // TODO figure out how to reset the cache here, if I _reset() here before throwing
     // it doesn't seem to work.
     // As it is now, this will burn the cache entry until the timeout fires.
     if (this._error) {
       throw this._error;
+    } else if (!this.hasValue) {
+      throw Error('Can only get value if SuspenseSubject has a value');
     }
-    return this._value;
+    return this._value as T;
   }
 
   get firstEmission(): Promise<void> {

package/src/firebaseApp.tsx

@@ -16,7 +16,7 @@ interface FirebaseAppProviderProps {
   suspense?: boolean;
 }
 
-// @ts-ignore: "__REACTFIRE_VERSION__" is replaced with actual ReactFire version (see babel.config.js)
+// @ts-expect-error: "__REACTFIRE_VERSION__" is replaced with actual ReactFire version (see babel.config.js)
 export const version = __REACTFIRE_VERSION__;
 
 const shallowEq = (a: { [key: string]: any }, b: { [key: string]: any }) => a === b || [...Object.keys(a), ...Object.keys(b)].every((key) => a[key] === b[key]);

package/src/functions.tsx

@@ -0,0 +1,26 @@
+import { httpsCallable as rxHttpsCallable } from 'rxfire/functions';
+import { ReactFireOptions, useObservable, ObservableStatus } from './';
+import { useFunctions } from '.';
+
+import type { HttpsCallableOptions } from 'firebase/functions';
+
+/**
+ * Calls a callable function.
+ *
+ * @param functionName - The name of the function to call
+ * @param options
+ */
+export function useCallableFunctionResponse<RequestData, ResponseData>(
+  functionName: string,
+  options?: ReactFireOptions<ResponseData> & {
+    httpsCallableOptions?: HttpsCallableOptions;
+    data?: RequestData;
+  }
+): ObservableStatus<ResponseData> {
+  const functions = useFunctions();
+  const observableId = `functions:callableResponse:${functionName}:${JSON.stringify(options?.data)}:${JSON.stringify(options?.httpsCallableOptions)}`;
+  const obsFactory = rxHttpsCallable<RequestData, ResponseData>(functions, functionName, options?.httpsCallableOptions);
+  const observable$ = obsFactory(options?.data);
+
+  return useObservable(observableId, observable$, options);
+}

package/src/index.ts

@@ -52,6 +52,7 @@ export * from './auth';
 export * from './database';
 export * from './firebaseApp';
 export * from './firestore';
+export * from './functions';
 export * from './performance';
 export * from './remote-config';
 export * from './storage';

package/src/{remote-config/index.tsx → remote-config.tsx}

@@ -1,17 +1,12 @@
-import { useRemoteConfig } from '../';
-import { useObservable, ObservableStatus } from '../useObservable';
-import { getValue, getString, getBoolean, getNumber, getAll, AllParameters } from './getValue';
+import { useRemoteConfig } from './';
+import { useObservable, ObservableStatus } from './useObservable';
+import { getValue, getString, getBoolean, getNumber, getAll, AllParameters } from 'rxfire/remote-config';
 import { Observable } from 'rxjs';
 
 import type { RemoteConfig, Value as RemoteConfigValue } from 'firebase/remote-config';
 
 type Getter$<T> = (remoteConfig: RemoteConfig, key: string) => Observable<T>;
 
-interface RemoteConfigWithPrivate extends RemoteConfig {
-  // This is a private API, assume optional
-  _storage?: { appName: string };
-}
-
 /**
  * Helper function to construct type safe functions. Since Remote Config has
  * methods that return different types for values, we need to be extra safe
@@ -23,9 +18,7 @@ interface RemoteConfigWithPrivate extends RemoteConfig {
 function useRemoteConfigValue_INTERNAL<T>(key: string, getter: Getter$<T>): ObservableStatus<T> {
   const remoteConfig = useRemoteConfig();
 
-  // INVESTIGATE need to use a public API to get at the app name, one doesn't appear to exist...
-  // we might need to iterate over the Firebase apps and check for remoteConfig equality? this works for now
-  const appName = (remoteConfig as RemoteConfigWithPrivate)._storage?.appName;
+  const appName = remoteConfig.app.name;
   const $value = getter(remoteConfig, key);
 
   const observableId = `remoteConfig:${key}:${getter.name}:${appName}`;
@@ -37,7 +30,6 @@ function useRemoteConfigValue_INTERNAL<T>(key: string, getter: Getter$<T>): Obse
  * Remote Config Value.
  *
  * @param key The parameter key in Remote Config
- * @param remoteConfig Optional instance. If not provided ReactFire will either grab the default instance or lazy load.
  */
 export function useRemoteConfigValue(key: string): ObservableStatus<RemoteConfigValue> {
   return useRemoteConfigValue_INTERNAL<RemoteConfigValue>(key, getValue);
@@ -46,7 +38,6 @@ export function useRemoteConfigValue(key: string): ObservableStatus<RemoteConfig
 /**
  * Convience method similar to useRemoteConfigValue. Returns a `string` from a Remote Config parameter.
  * @param key The parameter key in Remote Config
- * @param remoteConfig Optional instance. If not provided ReactFire will either grab the default instance or lazy load.
  */
 export function useRemoteConfigString(key: string): ObservableStatus<string> {
   return useRemoteConfigValue_INTERNAL<string>(key, getString);
@@ -55,7 +46,6 @@ export function useRemoteConfigString(key: string): ObservableStatus<string> {
 /**
  * Convience method similar to useRemoteConfigValue. Returns a `number` from a Remote Config parameter.
  * @param key The parameter key in Remote Config
- * @param remoteConfig Optional instance. If not provided ReactFire will either grab the default instance or lazy load.
  */
 export function useRemoteConfigNumber(key: string): ObservableStatus<number> {
   return useRemoteConfigValue_INTERNAL<number>(key, getNumber);
@@ -64,7 +54,6 @@ export function useRemoteConfigNumber(key: string): ObservableStatus<number> {
 /**
  * Convience method similar to useRemoteConfigValue. Returns a `boolean` from a Remote Config parameter.
  * @param key The parameter key in Remote Config
- * @param remoteConfig Optional instance. If not provided ReactFire will either grab the default instance or lazy load.
  */
 export function useRemoteConfigBoolean(key: string): ObservableStatus<boolean> {
   return useRemoteConfigValue_INTERNAL<boolean>(key, getBoolean);
@@ -73,7 +62,6 @@ export function useRemoteConfigBoolean(key: string): ObservableStatus<boolean> {
 /**
  * Convience method similar to useRemoteConfigValue. Returns allRemote Config parameters.
  * @param key The parameter key in Remote Config
- * @param remoteConfig Optional instance. If not provided ReactFire will either grab the default instance or lazy load.
  */
 export function useRemoteConfigAll(key: string): ObservableStatus<AllParameters> {
   return useRemoteConfigValue_INTERNAL<AllParameters>(key, getAll);

package/src/sdk.tsx

@@ -1,9 +1,11 @@
 import * as React from 'react';
 
+import type { AppCheck } from 'firebase/app-check';
 import type { Auth } from 'firebase/auth';
 import type { Analytics } from 'firebase/analytics';
 import type { Database } from 'firebase/database';
 import type { Firestore } from 'firebase/firestore';
+import type { Functions } from 'firebase/functions';
 import type { FirebasePerformance } from 'firebase/performance';
 import type { FirebaseStorage } from 'firebase/storage';
 import type { RemoteConfig } from 'firebase/remote-config';
@@ -13,39 +15,25 @@ import { ObservableStatus, useObservable } from './useObservable';
 import { from } from 'rxjs';
 import { ReactFireOptions } from '.';
 
-const AuthSdkContext = React.createContext<Auth | undefined>(undefined);
-const AnalyticsSdkContext = React.createContext<Analytics | undefined>(undefined);
-const DatabaseSdkContext = React.createContext<Database | undefined>(undefined);
-const FirestoreSdkContext = React.createContext<Firestore | undefined>(undefined);
-const StorageSdkContext = React.createContext<FirebaseStorage | undefined>(undefined);
-const PerformanceSdkContext = React.createContext<FirebasePerformance | undefined>(undefined);
-const RemoteConfigSdkContext = React.createContext<RemoteConfig | undefined>(undefined);
+export const AppCheckSdkContext = React.createContext<AppCheck | undefined>(undefined);
+export const AuthSdkContext = React.createContext<Auth | undefined>(undefined);
+export const AnalyticsSdkContext = React.createContext<Analytics | undefined>(undefined);
+export const DatabaseSdkContext = React.createContext<Database | undefined>(undefined);
+export const FirestoreSdkContext = React.createContext<Firestore | undefined>(undefined);
+export const FunctionsSdkContext = React.createContext<Functions | undefined>(undefined);
+export const StorageSdkContext = React.createContext<FirebaseStorage | undefined>(undefined);
+export const PerformanceSdkContext = React.createContext<FirebasePerformance | undefined>(undefined);
+export const RemoteConfigSdkContext = React.createContext<RemoteConfig | undefined>(undefined);
 
-type FirebaseSdks = Auth | Analytics | Database | Firestore | FirebasePerformance | FirebaseStorage | RemoteConfig;
+type FirebaseSdks = Analytics | AppCheck | Auth | Database | Firestore | FirebasePerformance | FirebaseStorage | Functions | RemoteConfig;
 
 function getSdkProvider<Sdk extends FirebaseSdks>(SdkContext: React.Context<Sdk | undefined>) {
   return function SdkProvider(props: React.PropsWithChildren<{ sdk: Sdk }>) {
-    const contextualAppName = useFirebaseApp().name;
-    let sdkAppName;
-
-    // @ts-ignore Auth doesn't have field 'app'
-    if (props.sdk.app) {
-      // @ts-ignore Auth doesn't have field 'app'
-      sdkAppName = props.sdk.app.name;
-
-      // @ts-ignore only Auth has field 'name'
-    } else if (props.sdk.name) {
-      // @ts-ignore only Auth has field 'name'
-      sdkAppName = props.sdk.name;
-    }
+    if (!props.sdk) throw new Error('no sdk provided');
 
-    if (sdkAppName !== contextualAppName) {
-      throw new Error('sdk was initialized with a different firebase app');
-    }
-
-    if (!props.sdk) {
-      throw new Error('no sdk provided');
-    }
+    const contextualAppName = useFirebaseApp().name;
+    const sdkAppName = props?.sdk?.app?.name;
+    if (sdkAppName !== contextualAppName) throw new Error('sdk was initialized with a different firebase app');
 
     return <SdkContext.Provider value={props.sdk} {...props} />;
   };
@@ -81,18 +69,22 @@ function useInitSdk<Sdk extends FirebaseSdks>(
   return useObservable<Sdk>(`firebase-sdk:${sdkName}:${firebaseApp.name}`, from(initializeSdk), options);
 }
 
+export const AppCheckProvider = getSdkProvider<AppCheck>(AppCheckSdkContext);
 export const AuthProvider = getSdkProvider<Auth>(AuthSdkContext);
 export const AnalyticsProvider = getSdkProvider<Analytics>(AnalyticsSdkContext);
 export const DatabaseProvider = getSdkProvider<Database>(DatabaseSdkContext);
 export const FirestoreProvider = getSdkProvider<Firestore>(FirestoreSdkContext);
+export const FunctionsProvider = getSdkProvider<Functions>(FunctionsSdkContext);
 export const PerformanceProvider = getSdkProvider<FirebasePerformance>(PerformanceSdkContext);
 export const StorageProvider = getSdkProvider<FirebaseStorage>(StorageSdkContext);
 export const RemoteConfigProvider = getSdkProvider<RemoteConfig>(RemoteConfigSdkContext);
 
+export const useAppCheck = () => useSdk<AppCheck>(AppCheckSdkContext);
 export const useAuth = () => useSdk<Auth>(AuthSdkContext);
 export const useAnalytics = () => useSdk<Analytics>(AnalyticsSdkContext);
 export const useDatabase = () => useSdk<Database>(DatabaseSdkContext);
 export const useFirestore = () => useSdk<Firestore>(FirestoreSdkContext);
+export const useFunctions = () => useSdk<Functions>(FunctionsSdkContext);
 export const usePerformance = () => useSdk<FirebasePerformance>(PerformanceSdkContext);
 export const useStorage = () => useSdk<FirebaseStorage>(StorageSdkContext);
 export const useRemoteConfig = () => useSdk<RemoteConfig>(RemoteConfigSdkContext);
@@ -102,10 +94,12 @@ type InitSdkHook<Sdk extends FirebaseSdks> = (
   options?: ReactFireOptions<Sdk>
 ) => ObservableStatus<Sdk>;
 
+export const useInitAppCheck: InitSdkHook<AppCheck> = (initializer, options) => useInitSdk<AppCheck>('appcheck', AppCheckSdkContext, initializer, options);
 export const useInitAuth: InitSdkHook<Auth> = (initializer, options) => useInitSdk<Auth>('auth', AuthSdkContext, initializer, options);
 export const useInitAnalytics: InitSdkHook<Analytics> = (initializer, options) => useInitSdk<Analytics>('analytics', AnalyticsSdkContext, initializer, options);
 export const useInitDatabase: InitSdkHook<Database> = (initializer, options) => useInitSdk<Database>('database', DatabaseSdkContext, initializer, options);
 export const useInitFirestore: InitSdkHook<Firestore> = (initializer, options) => useInitSdk<Firestore>('firestore', FirestoreSdkContext, initializer, options);
+export const useInitFunctions: InitSdkHook<Functions> = (initializer, options) => useInitSdk<Functions>('functions', FunctionsSdkContext, initializer, options);
 export const useInitPerformance: InitSdkHook<FirebasePerformance> = (initializer, options) =>
   useInitSdk<FirebasePerformance>('performance', PerformanceSdkContext, initializer, options);
 export const useInitRemoteConfig: InitSdkHook<RemoteConfig> = (initializer, options) =>

package/src/storage.tsx

@@ -1,33 +1,11 @@
 import * as React from 'react';
-import { getDownloadURL } from 'rxfire/storage';
-import { Observable } from 'rxjs';
+import { getDownloadURL, fromTask } from 'rxfire/storage';
 import { ReactFireOptions, useObservable, ObservableStatus, useStorage } from './';
 import { useSuspenseEnabledFromConfigAndContext } from './firebaseApp';
 import { ref } from 'firebase/storage';
 
 import type { UploadTask, UploadTaskSnapshot, StorageReference, FirebaseStorage } from 'firebase/storage';
 
-/**
- * modified version of rxFire's _fromTask
- *
- * @param task
- */
-function _fromTask(task: UploadTask) {
-  return new Observable<UploadTaskSnapshot>((subscriber) => {
-    const progress = (snap: UploadTaskSnapshot) => {
-      return subscriber.next(snap);
-    };
-    const error = (e: any) => subscriber.error(e);
-    const complete = () => {
-      return subscriber.complete();
-    };
-    task.on('state_changed', progress, error, complete);
-
-    // I REMOVED THE UNSUBSCRIBE RETURN BECAUSE IT CANCELS THE UPLOAD
-    // https://github.com/firebase/firebase-js-sdk/issues/1659
-  });
-}
-
 /**
  * Subscribe to the progress of a storage task
  *
@@ -37,7 +15,7 @@ function _fromTask(task: UploadTask) {
  */
 export function useStorageTask<T = unknown>(task: UploadTask, ref: StorageReference, options?: ReactFireOptions<T>): ObservableStatus<UploadTaskSnapshot | T> {
   const observableId = `storage:task:${ref.toString()}`;
-  const observable$ = _fromTask(task);
+  const observable$ = fromTask(task);
 
   return useObservable(observableId, observable$, options);
 }

package/src/useObservable.ts

@@ -63,55 +63,75 @@ export interface ObservableStatus<T> {
   firstValuePromise: Promise<void>;
 }
 
+function reducerFactory<T>(observable: SuspenseSubject<T>) {
+  return function reducer(state: ObservableStatus<T>, action: 'value' | 'error' | 'complete'): ObservableStatus<T> {
+    // always make sure these values are in sync with the observable
+    const newState = {
+      ...state,
+      hasEmitted: state.hasEmitted || observable.hasValue,
+      error: observable.ourError,
+      firstValuePromise: observable.firstEmission,
+    };
+    if (observable.hasValue) {
+      newState.data = observable.value;
+    }
+
+    switch (action) {
+      case 'value':
+        newState.status = 'success';
+        return newState;
+      case 'error':
+        newState.status = 'error';
+        return newState;
+      case 'complete':
+        newState.isComplete = true;
+        return newState;
+      default:
+        throw new Error(`invalid action "${action}"`);
+    }
+  };
+}
+
 export function useObservable<T = unknown>(observableId: string, source: Observable<T>, config: ReactFireOptions = {}): ObservableStatus<T> {
+  // Register the observable with the cache
   if (!observableId) {
     throw new Error('cannot call useObservable without an observableId');
   }
   const observable = preloadObservable(source, observableId);
 
+  // Suspend if suspense is enabled and no initial data exists
   const hasInitialData = config.hasOwnProperty('initialData') || config.hasOwnProperty('startWithValue');
-
+  const hasData = observable.hasValue || hasInitialData;
   const suspenseEnabled = useSuspenseEnabledFromConfigAndContext(config.suspense);
-
-  if (suspenseEnabled === true && !observable.hasValue && (!config?.initialData ?? !config?.startWithValue)) {
+  if (suspenseEnabled === true && !hasData) {
     throw observable.firstEmission;
   }
 
-  const [latest, setValue] = React.useState(() => (observable.hasValue ? observable.value : config.initialData ?? config.startWithValue));
-  const [isComplete, setIsComplete] = React.useState(false);
-  const [hasError, setHasError] = React.useState(false);
+  const initialState: ObservableStatus<T> = {
+    status: hasData ? 'success' : 'loading',
+    hasEmitted: hasData,
+    isComplete: false,
+    data: observable.hasValue ? observable.value : config?.initialData ?? config?.startWithValue,
+    error: observable.ourError,
+    firstValuePromise: observable.firstEmission,
+  };
+  const [status, dispatch] = React.useReducer<React.Reducer<ObservableStatus<T>, 'value' | 'error' | 'complete'>>(reducerFactory<T>(observable), initialState);
+
   React.useEffect(() => {
     const subscription = observable.subscribe({
-      next: (v) => {
-        setValue(() => v);
+      next: () => {
+        dispatch('value');
       },
       error: (e) => {
-        setHasError(true);
+        dispatch('error');
         throw e;
       },
       complete: () => {
-        setIsComplete(true);
+        dispatch('complete');
       },
     });
     return () => subscription.unsubscribe();
   }, [observable]);
 
-  let status: ObservableStatus<T>['status'];
-
-  if (hasError) {
-    status = 'error';
-  } else if (observable.hasValue || hasInitialData) {
-    status = 'success';
-  } else {
-    status = 'loading';
-  }
-
-  return {
-    status,
-    hasEmitted: observable.hasValue || hasInitialData,
-    isComplete: isComplete,
-    data: latest,
-    error: observable.ourError,
-    firstValuePromise: observable.firstEmission,
-  };
+  return status;
 }

package/dist/remote-config/getValue.d.ts

@@ -1,10 +0,0 @@
-import { Observable } from 'rxjs';
-import type { RemoteConfig, Value as RemoteConfigValue } from 'firebase/remote-config';
-export declare type AllParameters = {
-    [key: string]: RemoteConfigValue;
-};
-export declare function getValue(remoteConfig: RemoteConfig, key: string): Observable<RemoteConfigValue>;
-export declare function getString(remoteConfig: RemoteConfig, key: string): Observable<string>;
-export declare function getNumber(remoteConfig: RemoteConfig, key: string): Observable<number>;
-export declare function getBoolean(remoteConfig: RemoteConfig, key: string): Observable<boolean>;
-export declare function getAll(remoteConfig: RemoteConfig): Observable<AllParameters>;

package/src/remote-config/getValue.tsx

@@ -1,58 +0,0 @@
-import { Observable } from 'rxjs';
-import {
-  ensureInitialized,
-  getValue as rcGetValue,
-  getString as rcGetString,
-  getNumber as rcGetNumber,
-  getBoolean as rcGetBoolean,
-  getAll as rcGetAll,
-} from 'firebase/remote-config';
-
-import type { RemoteConfig, Value as RemoteConfigValue } from 'firebase/remote-config';
-
-export type AllParameters = {
-  [key: string]: RemoteConfigValue;
-};
-
-interface ParameterSettings<T> {
-  remoteConfig: RemoteConfig;
-  key: string;
-  getter: (key: string) => T;
-}
-
-// TODO(davideast): Replace with RxFire functions when they land
-function parameter$<T>({ remoteConfig, key, getter }: ParameterSettings<T>): Observable<T> {
-  return new Observable((subscriber) => {
-    ensureInitialized(remoteConfig).then(() => {
-      // 'this' for the getter loses context in the next()
-      // call, so it needs to be bound.
-      subscriber.next(getter.bind(remoteConfig)(key));
-    });
-  });
-}
-
-export function getValue(remoteConfig: RemoteConfig, key: string) {
-  const getter = () => rcGetValue(remoteConfig, key);
-  return parameter$({ remoteConfig, key, getter });
-}
-
-export function getString(remoteConfig: RemoteConfig, key: string) {
-  const getter = () => rcGetString(remoteConfig, key);
-  return parameter$<string>({ remoteConfig, key, getter });
-}
-
-export function getNumber(remoteConfig: RemoteConfig, key: string) {
-  const getter = () => rcGetNumber(remoteConfig, key);
-  return parameter$<number>({ remoteConfig, key, getter });
-}
-
-export function getBoolean(remoteConfig: RemoteConfig, key: string) {
-  const getter = () => rcGetBoolean(remoteConfig, key);
-  return parameter$<boolean>({ remoteConfig, key, getter });
-}
-
-export function getAll(remoteConfig: RemoteConfig) {
-  const getter = () => rcGetAll(remoteConfig);
-  // No key is needed for getAll()
-  return parameter$<AllParameters>({ remoteConfig, key: '', getter });
-}