reactfire 4.0.0-exp.e80fc49 → 4.0.0-exp.eb1428b

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,23 +1,44 @@
 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 | 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;
+export declare const AnalyticsProvider: (props: React.PropsWithChildren<{
+    sdk: Analytics;
+}>) => JSX.Element;
 export declare const DatabaseProvider: (props: React.PropsWithChildren<{
     sdk: Database;
 }>) => JSX.Element;
 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;
@@ -27,16 +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.e80fc49",
+  "version": "4.0.0-exp.eb1428b",
   "license": "MIT",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
@@ -14,19 +14,21 @@
     "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-2021720181311",
+    "firebase": "^9.0.0",
     "react": ">=16 || experimental"
   },
   "husky": {
@@ -81,8 +83,8 @@
     "babel-jest": "^26.6.3",
     "babel-plugin-minify-replace": "^0.5.0",
     "eslint-plugin-no-only-tests": "^2.6.0",
-    "firebase": "9.0.0-2021720181311",
-    "firebase-tools": "^9.16.0",
+    "firebase": "^9.0.1",
+    "firebase-tools": "^10.9.2",
     "globalthis": "^1.0.1",
     "husky": "^4.3.0",
     "jest-environment-jsdom": "^26.6.2",
@@ -99,7 +101,7 @@
     "typescript": "^4.2.4"
   },
   "dependencies": {
-    "rxfire": "6.0.0-rc.1",
+    "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/auth.tsx

@@ -24,15 +24,15 @@ export function useUser<T = unknown>(options?: ReactFireOptions<T>): ObservableS
 
   const observableId = `auth:user:${auth.name}`;
   const observable$ = user(auth);
+  const _options: ReactFireOptions<T> = {...options} ?? {};
 
-  let currentUser = auth.currentUser;
-
-  // Only use options.initialData if auth.currentUser is unavailable
-  if (!currentUser && (options?.initialData ?? options?.startWithValue)) {
-    currentUser = options.initialData ?? options.startWithValue;
+  // only set/override initialData if auth has finished loading
+  if (auth.currentUser !== undefined) {
+    _options.initialData = auth.currentUser;
+    _options.startWithValue = auth.currentUser;
   }
 
-  return useObservable(observableId, observable$, { ...options, initialData: currentUser });
+  return useObservable(observableId, observable$, _options);
 }
 
 export function useIdTokenResult(user: User, forceRefresh: boolean = false, options?: ReactFireOptions<IdTokenResult>): ObservableStatus<IdTokenResult> {

package/src/database.tsx

@@ -1,9 +1,6 @@
-import { list, object, QueryChange, listVal } from 'rxfire/database';
+import { list, object, QueryChange, listVal, objectVal } from 'rxfire/database';
 import { ReactFireOptions, useObservable, checkIdField, ObservableStatus, ReactFireGlobals } from './';
 
-import { Observable } from 'rxjs';
-import { map } from 'rxjs/operators';
-
 import type { Query as DatabaseQuery, DatabaseReference } from 'firebase/database';
 
 // Since we're side-effect free, we need to ensure our observableId cache is global
@@ -34,33 +31,10 @@ export function useDatabaseObject<T = unknown>(ref: DatabaseReference, options?:
   return useObservable(observableId, observable$, options);
 }
 
-// ============================================================================
-// TODO: switch to rxfire's objectVal once this PR is merged:
-// https://github.com/firebase/firebase-js-sdk/pull/2352
-
-function objectVal<T>(query: DatabaseQuery, keyField?: string): Observable<T> {
-  return object(query).pipe(map((change) => changeToData(change, keyField) as T));
-}
-
-function changeToData(change: QueryChange, keyField?: string): {} {
-  const val = change.snapshot.val();
-
-  // don't worry about setting IDs if the value is a primitive type
-  if (typeof val !== 'object') {
-    return val;
-  }
-
-  return {
-    ...change.snapshot.val(),
-    ...(keyField ? { [keyField]: change.snapshot.key } : null),
-  };
-}
-// ============================================================================
-
 export function useDatabaseObjectData<T>(ref: DatabaseReference, options?: ReactFireOptions<T>): ObservableStatus<T> {
   const idField = options ? checkIdField(options) : 'NO_ID_FIELD';
   const observableId = `database:objectVal:${ref.toString()}:idField=${idField}`;
-  const observable$ = objectVal<T>(ref, idField);
+  const observable$ = objectVal<T>(ref, { keyField: idField });
 
   return useObservable(observableId, observable$, options);
 }
@@ -87,6 +61,6 @@ export function useDatabaseListData<T = { [key: string]: unknown }>(
 ): ObservableStatus<T[] | null> {
   const idField = options ? checkIdField(options) : 'NO_ID_FIELD';
   const observableId = `database:listVal:${getUniqueIdForDatabaseQuery(ref)}:idField=${idField}`;
-  const observable$ = listVal<T>(ref, idField);
+  const observable$ = listVal<T>(ref, { keyField: idField });
   return useObservable(observableId, observable$, options);
 }

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/firestore.tsx

@@ -63,7 +63,7 @@ export function useFirestoreDocData<T = unknown>(ref: DocumentReference<T>, opti
   const idField = options ? checkIdField(options) : 'NO_ID_FIELD';
 
   const observableId = `firestore:docData:${ref.firestore.app.name}:${ref.path}:idField=${idField}`;
-  const observable = docData(ref, idField);
+  const observable = docData(ref, { idField });
 
   return useObservable(observableId, observable, options);
 }
@@ -75,7 +75,7 @@ export function useFirestoreDocDataOnce<T = unknown>(ref: DocumentReference<T>,
   const idField = options ? checkIdField(options) : 'NO_ID_FIELD';
 
   const observableId = `firestore:docDataOnce:${ref.firestore.app.name}:${ref.path}:idField=${idField}`;
-  const observable$ = docData(ref, idField).pipe(first());
+  const observable$ = docData(ref, { idField }).pipe(first());
 
   return useObservable(observableId, observable$, options);
 }
@@ -96,7 +96,7 @@ export function useFirestoreCollection<T = DocumentData>(query: FirestoreQuery<T
 export function useFirestoreCollectionData<T = DocumentData>(query: FirestoreQuery<T>, options?: ReactFireOptions<T[]>): ObservableStatus<T[]> {
   const idField = options ? checkIdField(options) : 'NO_ID_FIELD';
   const observableId = `firestore:collectionData:${getUniqueIdForFirestoreQuery(query)}:idField=${idField}`;
-  const observable$ = collectionData(query, idField);
+  const observable$ = collectionData(query, { idField });
 
   return useObservable(observableId, observable$, options);
 }

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,8 +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';
@@ -12,38 +15,25 @@ import { ObservableStatus, useObservable } from './useObservable';
 import { from } from 'rxjs';
 import { ReactFireOptions } from '.';
 
-const AuthSdkContext = React.createContext<Auth | 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 | 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} />;
   };
@@ -79,16 +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);
@@ -98,9 +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);
 }