react-query-firebase 1.0.2 → 1.0.4

package/src/context/FirebaseContextProvider.tsx

@@ -0,0 +1,173 @@
+import React, { PropsWithChildren, useMemo } from "react";
+import { FirebaseContext } from "./FirebaseContext";
+import { connectAuthEmulator, getAuth } from "firebase/auth";
+import { getAnalytics } from "firebase/analytics";
+import { getRemoteConfig, RemoteConfigSettings } from "firebase/remote-config";
+import { connectFirestoreEmulator, getFirestore } from "firebase/firestore";
+import { FirebaseOptions, initializeApp } from "firebase/app";
+
+/**
+ * @inline
+ */
+export type FirebaseContextProviderFirestoreEmulatorConfig = {
+    /**
+     * Host to connect to Firebase Firestore Emulator
+     */
+    host: string;
+    /**
+     * Port to connect to Firebase Firestore Emulator
+     */
+    port: number;
+};
+
+/**
+ * @inline
+ */
+export type FirebaseContextProviderAuthEmulatorConfig = {
+    /**
+     * Host to connect to Firebase Auth Emulator
+     */
+    host: string;
+};
+
+/**
+ * @inline
+ */
+export type FirebaseContextProviderEmulators = {
+    /**
+     * Defines configuration for Firebase Firestore emulator. Optional.
+     */
+    firestore?: FirebaseContextProviderFirestoreEmulatorConfig;
+    /**
+     * Defines configuration for Firebase Auth emulator. Optional
+     */
+    auth?: FirebaseContextProviderAuthEmulatorConfig;
+};
+
+/**
+ * @inline
+ */
+export type FirebaseContextProviderProps = PropsWithChildren & {
+    /**
+     * Defines configuration for firebase emulators
+     */
+    emulators?: FirebaseContextProviderEmulators;
+    /**
+     * Configuration options for Firebase initialization. {@link https://firebase.google.com/docs/web/setup#config-object | Learn about the Firebase config object}
+     */
+    options: FirebaseOptions;
+    /**
+     * Flag indicating whether Firebase Auth should be enabled.
+     */
+    authEnabled?: boolean;
+    /**
+     * Flag indicating whether Firebase Analytics should be enabled.
+     * @defaultValue `true`
+     */
+    analyticsEnabled?: boolean;
+    /**
+     * Flag indicating whether Firebase Firestore should be enabled.
+     * @defaultValue `true`
+     */
+    firestoreEnabled?: boolean;
+    /**
+     * Configuration options for Firebase Remote Config Settings. {@link https://firebase.google.com/docs/reference/js/remote-config.remoteconfigsettings | Learn about the Firebase Remote COnfig Settings object}
+     * @defaultValue `true`
+     */
+    remoteConfigSettings?: RemoteConfigSettings;
+    /**
+     * Configuration options for Firebase Remote Config Defaults.
+     */
+    remoteConfigDefaults?: { [key: string]: string | number | boolean };
+    /**
+     * Flag indicating whether Firebase Remote Config should be enabled.
+     * @defaultValue `true`
+     */
+    remoteConfigEnabled?: boolean;
+};
+
+/**
+ * FirebaseContextProvider component configures and provides Firebase services to its children.
+ * Initializes Firebase app and enables optional Firebase services such as Firestore, Auth, Analytics,
+ * and Remote Config based on the provided configuration and parameters.
+ *
+ * @group Component
+ *
+ * @param {FirebaseContextProviderProps} props
+ *
+ * @returns {FirebaseContextProvider<FirebaseContextProviderProps>}
+ *
+ * @example
+ * ```jsx
+ * const firebaseConfig = {};
+ * export const App = () => {
+ *  return (
+ *      <FirebaseContextProvider options={firebaseConfig}>
+ *          <ChildComponent />
+ *      </FirebaseContextProvider>
+ *  );
+ * };
+ * ```
+ */
+export const FirebaseContextProvider: React.FC<FirebaseContextProviderProps> = ({
+    emulators,
+    options,
+    children,
+    authEnabled = true,
+    firestoreEnabled = true,
+    analyticsEnabled = true,
+    remoteConfigEnabled = true,
+    remoteConfigSettings,
+    remoteConfigDefaults = {}
+}) => {
+    const firebase = useMemo(() => {
+        return initializeApp(options);
+    }, [options]);
+
+    const contextValue = useMemo(() => {
+        const value: Partial<React.ContextType<typeof FirebaseContext>> = {};
+
+        if (firestoreEnabled) {
+            const firestore = getFirestore(firebase);
+
+            if (emulators?.firestore?.host && emulators?.firestore?.port) {
+                connectFirestoreEmulator(firestore, emulators.firestore.host, emulators.firestore.port);
+            }
+
+            value.firestore = firestore;
+        }
+
+        if (authEnabled) {
+            const auth = getAuth(firebase);
+            if (emulators?.auth?.host) {
+                connectAuthEmulator(auth, emulators?.auth?.host, {
+                    disableWarnings: true
+                });
+            }
+            value.auth = auth;
+        }
+
+        if (analyticsEnabled && options.measurementId && typeof window !== "undefined") {
+            const analytics = getAnalytics(firebase);
+            value.analytics = analytics;
+        }
+
+        if (remoteConfigEnabled && typeof window !== "undefined") {
+            const remoteConfig = getRemoteConfig(firebase);
+            if (remoteConfigSettings) {
+                remoteConfig.settings.fetchTimeoutMillis = remoteConfigSettings.fetchTimeoutMillis;
+                remoteConfig.settings.minimumFetchIntervalMillis = remoteConfigSettings.minimumFetchIntervalMillis;
+                remoteConfig.defaultConfig = remoteConfigDefaults;
+            }
+            value.remoteConfig = remoteConfig;
+        }
+
+        return { firebase, ...value };
+    }, [firebase]);
+
+    return (
+        <FirebaseContext.Provider value={contextValue as React.ContextType<typeof FirebaseContext>}>
+            {children}
+        </FirebaseContext.Provider>
+    );
+};

package/src/context/index.ts

@@ -0,0 +1 @@
+export * from "./FirebaseContextProvider";

package/src/firestore/index.ts

@@ -1,3 +1,4 @@
+export * from "./useFirestore";
 export * from "./useAddDocMutation";
 export * from "./useBatchWrite";
 export * from "./useCollectionReference";

package/src/firestore/useAddDocMutation.ts

@@ -28,6 +28,17 @@ export type UseAddDocMutationOptions<
     >;
 };
 
+/**
+ * Provides a mutation hook to add a document to a Firestore collection utilizing React Query's `useMutation`.
+ * It handles addition and optional conversion of the document data in Firestore.
+ *
+ * @param {Object} options - Options for the mutation hook
+ * @param {FirebaseFirestore.CollectionReference<AppModelType>} options.reference - Firestore collection reference where the document should be added.
+ * @param {FirebaseFirestore.FirestoreDataConverter<DbModelType>} [options.converter] - Optional data converter for reading and writing Firestore documents.
+ * @param {UseMutationOptions<AppModelType, Error, { data: DbModelType }, TContext>} [options.options={}] - Optional configuration for the mutation.
+ *
+ * @returns {UseMutationResult<AppModelType, Error, { data: DbModelType }, TContext>} The mutation hook result containing status, error, and data of the mutation process.
+ */
 export const useAddDocMutation = <
     AppModelType extends DocumentData = DocumentData,
     DbModelType extends DocumentData = DocumentData,

package/src/firestore/useBatchWrite.ts

@@ -2,7 +2,7 @@ import { useMutation, UseMutationOptions } from "@tanstack/react-query";
 import { writeBatch, WriteBatch } from "firebase/firestore";
 
 import { FirebaseError } from "firebase/app";
-import { useFirestore } from "../useFirestore";
+import { useFirestore } from "./useFirestore";
 
 export type UseBatchWriteVariables = (batch: WriteBatch) => Promise<void> | void;
 
@@ -10,6 +10,13 @@ export type UseBatchWriteOptions<TContext = unknown> = {
     options?: Omit<UseMutationOptions<void, FirebaseError, UseBatchWriteVariables, TContext>, "mutationFn">;
 };
 
+/**
+ * Custom hook to perform batch write operations using Firestore.
+ * Utilizes a mutation to carry out the batch write transaction.
+ * @template TContext - The type of context that can be passed into the hook, defaults to unknown.
+ * @param {Object} options - The configuration options for the mutation operation.
+ * @returns {Object} Returns an object composed of elements returned by useMutation, including properties such as status, and functions to trigger and control the mutation process.
+ */
 export const useBatchWrite = <TContext = unknown>({ options = {} }: UseBatchWriteOptions<TContext> = {}) => {
     const db = useFirestore();
 

package/src/firestore/useCollectionReference.ts

@@ -1,7 +1,7 @@
 import { collection, CollectionReference, DocumentData, DocumentReference } from "firebase/firestore";
 
 import { useMemo } from "react";
-import { useFirestore } from "../useFirestore";
+import { useFirestore } from "./useFirestore";
 
 export type UseCollectionReferenceOptions<AppModelType, DbModelType extends DocumentData = DocumentData> = {
     reference?: CollectionReference<AppModelType, DbModelType> | DocumentReference<AppModelType, DbModelType>;
@@ -9,6 +9,17 @@ export type UseCollectionReferenceOptions<AppModelType, DbModelType extends Docu
     pathSegments?: string[];
 };
 
+/**
+ * Creates a reference to a Firestore collection based on the provided path, reference, and path segments.
+ *
+ * This hook utilizes useMemo for optimization, ensuring the collection reference is recalculated only when its dependencies change.
+ *
+ * @param {UseCollectionReferenceOptions<AppModelType, DbModelType>} options - The options including path, reference, and pathSegments to construct the Firestore collection reference.
+ * @param {string} options.path - The base path for the collection.
+ * @param {FirestoreReference} options.reference - An optional Firestore reference object that should be of type "collection".
+ * @param {string[]} options.pathSegments - Additional path segments to append to the base path.
+ * @returns {CollectionReference} A Firestore collection reference constructed using the specified path, reference, and path segments.
+ */
 export const useCollectionReference = <AppModelType, DbModelType extends DocumentData = DocumentData>({
     path,
     reference,

package/src/firestore/useCompositeFilter.ts

@@ -29,6 +29,14 @@ export type UseCompositeFilter<DbModelType extends CompositeFilterDocumentData =
     query?: CompositeFilter<DbModelType>;
 };
 
+/**
+ * Constructs a composite query filter based on the provided query structure.
+ * It recursively builds query constraints using logical "or" or "and" operators.
+ *
+ * @param {QueryElement<DbModelType>} query - The query element or structure to be evaluated and transformed into filter constraints.
+ * @returns {QueryFilterConstraint | null} A constructed query filter constraint based on the input query, or null if no valid constraints can be derived.
+ */
+
 const buildCompositeQuery = <DbModelType extends CompositeFilterDocumentData = CompositeFilterDocumentData>(
     query: QueryElement<DbModelType>
 ): QueryFilterConstraint | null => {
@@ -51,6 +59,16 @@ const buildCompositeQuery = <DbModelType extends CompositeFilterDocumentData = C
     return null;
 };
 
+/**
+ * A custom hook that generates a composite filter for database queries, using the provided query configuration.
+ * It applies either an 'OR' or 'AND' logical operation based on the type specified in the query.
+ *
+ * @param {Object} query - The query configuration object that contains subqueries and a type for logical combination.
+ * @param {string} query.type - The type of composite operation ('or'/'and').
+ * @param {Array} query.children - An array of subqueries that will be processed to form the composite filter.
+ *
+ * @returns {(Function|undefined)} A composite query filter constraint function formed by combining subqueries or undefined if there are no valid constraints.
+ */
 export const useCompositeFilter = <DbModelType extends CompositeFilterDocumentData = CompositeFilterDocumentData>({
     query
 }: UseCompositeFilter<DbModelType>) => {

package/src/firestore/useCountQuery.ts

@@ -25,6 +25,20 @@ type UseCountQueryOptions<
     compositeFilter?: QueryCompositeFilterConstraint;
 };
 
+/**
+ * Executes a query with specified constraints and returns the count of matched documents.
+ *
+ * This function utilizes React Query to asynchronously fetch the count of documents from a server database
+ * that match the provided query constraints and an optional composite filter.
+ *
+ * @param {UseCountQueryOptions<AppModelType, DbModelType>} options - Configuration options for the query.
+ * @param {AppModelType extends DocumentData = DocumentData} [options.options] - Additional options for the React Query.
+ * @param {unknown} [options.query] - Reference to the query object to be executed.
+ * @param {unknown[]} [options.queryConstraints=[]] - An array of constraints to apply to the query.
+ * @param {unknown} [options.compositeFilter] - An optional composite filter to apply to the query.
+ * @returns {UseQueryResult<number>} An object containing the number of documents that match the query.
+ */
+
 export const useCountQuery = <
     AppModelType extends DocumentData = DocumentData,
     DbModelType extends DocumentData = DocumentData

package/src/firestore/useDeleteDocMutation.ts

@@ -17,6 +17,13 @@ export type UseDeleteDocMutationOptions<
     options?: Omit<UseMutationOptions<void, FirebaseError, void, TContext>, "mutationFn" | "mutationKey">;
 };
 
+/**
+ * A custom hook that provides a mutation function to delete a document from the database.
+ * @param {UseDeleteDocMutationOptions<AppModelType, DbModelType, TContext>} options - An object containing the reference to the document and additional options for the mutation.
+ * @param {FirestoreReference<AppModelType, DbModelType>} options.reference - The reference to the document that needs to be deleted.
+ * @param {object} options.options - Additional options for the mutation, if any (default is an empty object).
+ * @returns {UseMutationResult} An object returned by the `useMutation` hook which includes properties and methods to control the mutation's execution and track its state.
+ */
 export const useDeleteDocMutation = <
     AppModelType extends DocumentData = DocumentData,
     DbModelType extends DocumentData = DocumentData,

package/src/firestore/useDocReference.ts

@@ -1,7 +1,7 @@
 import { doc, CollectionReference, DocumentData, DocumentReference, Firestore } from "firebase/firestore";
 
 import { useEffect, useRef } from "react";
-import { useFirestore } from "../useFirestore";
+import { useFirestore } from "./useFirestore";
 
 export type UseDocReferenceOptions<AppModelType, DbModelType extends DocumentData = DocumentData> = {
     reference?: CollectionReference<AppModelType, DbModelType> | DocumentReference<AppModelType, DbModelType>;
@@ -9,6 +9,18 @@ export type UseDocReferenceOptions<AppModelType, DbModelType extends DocumentDat
     pathSegments?: string[];
 };
 
+/**
+ * Generates a document reference for a specified path or reference in Firestore.
+ * If a reference is not provided, it constructs a document reference using the Firestore instance, path, and path segments.
+ *
+ * @param {Firestore} db - The Firestore database instance used to create the document reference.
+ * @param {UseDocReferenceOptions<AppModelType, DbModelType>} options - An object containing the path, path segments, and optional reference.
+ * @param {string} options.path - The path to the document in the Firestore database.
+ * @param {string[]} [options.pathSegments] - Optional additional segments to join with the path.
+ * @param {DocumentReference | CollectionReference} [options.reference] - Optional Firestore reference object that influences how the document reference is constructed.
+ *
+ * @returns {DocumentReference<AppModelType, DbModelType> | null} A Firestore document reference if the path is specified; otherwise, returns null if path is not provided.
+ */
 const getDocReference = <AppModelType, DbModelType extends DocumentData = DocumentData>(
     db: Firestore,
     { path, pathSegments, reference }: UseDocReferenceOptions<AppModelType, DbModelType>
@@ -26,6 +38,18 @@ const getDocReference = <AppModelType, DbModelType extends DocumentData = Docume
     ) as DocumentReference<AppModelType, DbModelType>;
 };
 
+/**
+ * Custom hook to generate and manage a Firestore document reference.
+ * This hook facilitates the retrieval of a Firestore document reference based on given options such as path and reference data.
+ * The reference is updated whenever the associated path, reference, or path segments change.
+ *
+ * @param {UseDocReferenceOptions<AppModelType, DbModelType>} options - Configuration options for setting up the document reference.
+ * @param {string} options.path - The path to the Firestore document.
+ * @param {DbModelType} options.reference - Reference data for the document, providing additional context or specifics.
+ * @param {string[]} options.pathSegments - Parts of the path to construct the full document path dynamically.
+ *
+ * @returns {DocumentReference<AppModelType, DbModelType> | null} The Firestore document reference corresponding to the provided path and options, or null if not initialized.
+ */
 export const useDocReference = <AppModelType, DbModelType extends DocumentData = DocumentData>({
     path,
     reference,

package/src/firestore/useDocReferences.ts

@@ -1,7 +1,7 @@
 import { CollectionReference, doc, DocumentData, DocumentReference } from "firebase/firestore";
 
 import { useMemo } from "react";
-import { useFirestore } from "../useFirestore";
+import { useFirestore } from "./useFirestore";
 
 export type UseDocReferencesOptions<AppModelType, DbModelType extends DocumentData = DocumentData> = {
     reference?: CollectionReference<AppModelType, DbModelType> | DocumentReference<AppModelType, DbModelType>;
@@ -9,6 +9,22 @@ export type UseDocReferencesOptions<AppModelType, DbModelType extends DocumentDa
     pathSegments?: string[];
 };
 
+/**
+ * A custom hook to generate document references for Firebase Firestore documents using given
+ * reference options.
+ *
+ * The hook accepts an array of options, where each option may contain a path,
+ * an existing reference, or path segments, and returns an array of generated
+ * Firestore document references based on those options. The references can be used
+ * to interact with the Firestore database documents. It uses memoization to optimize
+ * reference generation.
+ *
+ * @param {UseDocReferencesOptions<AppModelType, DbModelType>[]} references - An array of options
+ * specifying how to generate document references. Each option may include a `path`
+ * as a string, a `reference` as a Firestore reference, and `pathSegments` as an array of strings.
+ * @returns {DocumentReference<AppModelType, DbModelType>[]} An array of Firestore document references
+ * generated from the options provided.
+ */
 export const useDocReferences = <AppModelType, DbModelType extends DocumentData = DocumentData>(
     references: UseDocReferencesOptions<AppModelType, DbModelType>[]
 ) => {

package/src/firestore/useFirestore.ts

@@ -0,0 +1,13 @@
+import { useContext } from "react";
+import { FirebaseContext } from "../context/FirebaseContext";
+
+/**
+ * Provides a hook to access the Firestore instance from the Firebase context.
+ * It extracts the Firestore object from the Firebase context, allowing components to interact with Firestore services.
+ *
+ * @returns {firestore.Firestore} The Firestore instance from the Firebase context.
+ */
+export const useFirestore = () => {
+    const { firestore } = useContext(FirebaseContext);
+    return firestore;
+};

package/src/firestore/useGetDocData.ts

@@ -1,6 +1,6 @@
 import { CollectionReference, DocumentData, DocumentReference } from "firebase/firestore";
 
-import { useFirestore } from "../useFirestore";
+import { useFirestore } from "./useFirestore";
 import { getDocData } from "./utils/getDocData";
 import { useQuery, UseQueryOptions } from "@tanstack/react-query";
 
@@ -15,6 +15,14 @@ type UseGetDocOptions<
     reference: CollectionReference<AppModelType, DbModelType> | DocumentReference<AppModelType, DbModelType>;
 };
 
+/**
+ * Custom React Hook to retrieve document data from Firestore using specified parameters.
+ * @param {Object} options - The options for configuring the Firestore query.
+ * @param {string} reference - The reference to the document in Firestore.
+ * @param {string} path - The path to the document in Firestore.
+ * @param {Array<string>} pathSegments - Segments of the path to document in Firestore.
+ * @returns {Object} Result of the query containing document data and query status.
+ */
 export const useGetDocData = <
     AppModelType extends DocumentData = DocumentData,
     DbModelType extends DocumentData = DocumentData

package/src/firestore/useInfiniteQuery.ts

@@ -52,6 +52,13 @@ type UseInfiniteQueryOptions<
     converter?: FirestoreDataConverter<AppModelType, DbModelType>;
 };
 
+/**
+ * Custom hook that creates an infinite query using Firestore, allowing for query constraints, composite filters, and converters.
+ * It fetches data in pages and can load more as required.
+ *
+ * @param {UseInfiniteQueryOptions<AppModelType, DbModelType>} options - Configuration options for the infinite query, including Firestore query reference, query constraints, composite filter, and data converter.
+ * @returns {UseInfiniteQueryResult<InfiniteData<AppModelType[]>>} Result object containing the infinite data and methods for fetching more pages.
+ */
 export const useInfiniteQuery = <
     AppModelType extends DocumentData = DocumentData,
     DbModelType extends DocumentData = DocumentData

package/src/firestore/useQuery.ts

@@ -27,6 +27,20 @@ type UseQueryOptions<
     converter?: FirestoreDataConverter<AppModelType, DbModelType>;
 };
 
+/**
+ * Executes a query on a Firestore-like data source and returns the resulting documents as an array.
+ *
+ * This hook utilizes an abstraction over React Query to asynchronously fetch data based on the provided query
+ * reference and constraints. It supports optional filtering, conversion, and additional query constraints.
+ *
+ * @param {UseQueryOptions<AppModelType, DbModelType>}  options - Configuration options for the query.
+ * @param {DocumentReference<AppModelType>}  queryReference - The reference to the query to be executed.
+ * @param {QueryConstraint[]}  queryConstraints - Additional constraints to fine-tune the query.
+ * @param {QueryConstraint}  compositeFilter - Optional composite filter to apply to the query.
+ * @param {FirestoreDataConverter<AppModelType>}  converter - Optional data converter for transforming snapshots.
+ *
+ * @returns {UseQueryResult<AppModelType[]>} Result containing an array of documents that match the query criteria.
+ */
 export const useQuery = <
     AppModelType extends DocumentData = DocumentData,
     DbModelType extends DocumentData = DocumentData

package/src/firestore/useRunTransaction.ts

@@ -2,7 +2,7 @@ import { useMutation, UseMutationOptions } from "@tanstack/react-query";
 import { runTransaction, Transaction } from "firebase/firestore";
 
 import { FirebaseError } from "firebase/app";
-import { useFirestore } from "../useFirestore";
+import { useFirestore } from "./useFirestore";
 
 export type UseRunTransactionValues = <AppModelType = unknown>(transaction: Transaction) => AppModelType;
 
@@ -10,6 +10,13 @@ export type UseRunTransactionOptions<AppModelType = unknown, TContext = unknown>
     options?: Omit<UseMutationOptions<AppModelType, FirebaseError, UseRunTransactionValues, TContext>, "mutationFn">;
 };
 
+/**
+ * Custom hook to execute a Firestore transaction using the useMutation hook.
+ *
+ * @param {UseRunTransactionOptions<AppModelType, TContext>} options - Configuration options for running the transaction.
+ * @param {Object} options.options - Options to customize the behavior of useMutation and runTransaction.
+ * @returns {UseMutationResult} The result object from the useMutation hook, allowing to track the transaction state and outcome.
+ */
 export const useRunTransaction = <AppModelType = unknown, TContext = unknown>({
     options = {}
 }: UseRunTransactionOptions<AppModelType, TContext>) => {

package/src/firestore/useSetDocMutation.ts

@@ -20,6 +20,15 @@ export type UseSetDocMutationOptions<
     >;
 };
 
+/**
+ * Custom hook to create a mutation for setting a document in a Firestore-like database.
+ * The mutation can be configured with options and reference to specific document path.
+ *
+ * @param {UseSetDocMutationOptions<AppModelType, DbModelType, TContext>} param0 - The options for configuring the mutation, including the document reference and additional mutation options.
+ * @param {Object} param0.reference - The reference object that contains the path to the document.
+ * @param {Object} param0.options - Additional options for the mutation, can configure aspects like onSuccess or onError callbacks.
+ * @returns {MutationResult} The result of the mutation operation, which includes states like isLoading, isSuccess, isError, and methods to control the mutation process.
+ */
 export const useSetDocMutation = <
     AppModelType = unknown,
     DbModelType extends DocumentData = DocumentData,

package/src/firestore/useUpdateDocMutation.ts

@@ -28,6 +28,25 @@ export type UseUpdateDocMutationOptions<
     >;
 };
 
+/**
+ * Custom hook that sets up a mutation for updating a document in a Firestore database.
+ *
+ * This hook utilizes `useMutation` for performing asynchronous operations to update the document
+ * and retrieve the latest data snapshot. The update functionality can be configured with a custom
+ * converter if needed.
+ *
+ * @param {UseUpdateDocMutationOptions<AppModelType, DbModelType, TContext>} options - Configuration options for the mutation,
+ * including Firestore reference, an optional Firestore data converter, and additional mutation options.
+ *
+ * `reference` - The Firestore document reference that identifies the document to be updated.
+ *
+ * `converter` - An optional Firestore converter for transforming the database response into a custom type.
+ *
+ * `options` - Additional options that customize the mutation's behavior.
+ *
+ * @returns {UseMutationResult<AppModelType, Error, {data: AppModelType}, TContext>} An object returned by `useMutation`
+ * which includes functions to start the mutation and properties that represent the different states of the mutation.
+ */
 export const useUpdateDocMutation = <
     AppModelType extends DocumentData = DocumentData,
     DbModelType extends DocumentData = DocumentData,

package/src/firestore/utils/getDocData.ts

@@ -6,6 +6,20 @@ export type GetDocDataOptions<
     DbModelType extends DocumentData = DocumentData
 > = GetDocSnapOptions<AppModelType, DbModelType>;
 
+/**
+ * Asynchronously retrieves document data from a specified database and reference.
+ * Utilizes the helper function `getDocSnap` to fetch the document snapshot and
+ * checks if the document exists before returning its data.
+ *
+ * @param {Object} options - The options for fetching document data.
+ * @param {FirebaseFirestore} options.db - The Firestore database instance.
+ * @param {DocumentReference=} options.reference - The document reference. This is an optional parameter.
+ * @param {string=} options.path - The path to the document in the database. This is an optional parameter.
+ * @param {Array<string>=} options.pathSegments - The path segments for the document's path. This is an optional parameter.
+ *
+ * @returns {Promise<AppModelType | null>} Returns a promise that resolves to the document data if it exists,
+ * or null if the document does not exist.
+ */
 export const getDocData = async <
     AppModelType extends DocumentData = DocumentData,
     DbModelType extends DocumentData = DocumentData

package/src/firestore/utils/getDocRef.ts

@@ -10,6 +10,17 @@ export type GetDocRefOptions<
     pathSegments?: string[];
 };
 
+/**
+ * Retrieves a document reference based on provided database options.
+ * Either `reference` or `path` must be provided, not both.
+ *
+ * @param {Object} options - The options for getting a document reference.
+ * @param {Firestore} options.db - The Firestore database instance.
+ * @param {DocumentReference | CollectionReference | null} [options.reference] - Reference to a document or collection.
+ * @param {string | null} [options.path] - Path to the document.
+ * @param {string[] | null} [options.pathSegments] - Additional path segments if any.
+ * @returns {DocumentReference<AppModelType, DbModelType>} The document reference.
+ */
 export const getDocRef = async <
     AppModelType extends DocumentData = DocumentData,
     DbModelType extends DocumentData = DocumentData

package/src/firestore/utils/getDocSnap.ts

@@ -6,6 +6,22 @@ export type GetDocSnapOptions<
     DbModelType extends DocumentData = DocumentData
 > = GetDocRefOptions<AppModelType, DbModelType>;
 
+/**
+ * Asynchronously retrieves a document snapshot from Firestore using a specified document reference
+ * or path information. This function handles getting the appropriate document reference based on
+ * the parameters provided, and then fetches the document data from Firestore.
+ *
+ * @param {GetDocSnapOptions<AppModelType, DbModelType>} options - An object containing options
+ *                                                                for retrieving the document
+ *                                                                snapshot.
+ * @param {DocumentData} options.db - The Firestore database instance to perform the operation on.
+ * @param {string} options.reference - A string representing a direct Firestore document reference.
+ * @param {string} options.path - A Firestore path string leading to the document.
+ * @param {string[]} options.pathSegments - An array of path segments to build the Firestore path.
+ * @returns {Promise<DocumentData | null>} A promise that resolves to the document data if the
+ *                                         document exists, or `null` if the document does not exist
+ *                                         or if the reference could not be obtained.
+ */
 export const getDocSnap = async <
     AppModelType extends DocumentData = DocumentData,
     DbModelType extends DocumentData = DocumentData

package/src/index.ts

@@ -1,10 +1,5 @@
-export * from "./useAuth";
-export * from "./useFirebase";
-export * from "./useFirestore";
-export * from "./FirebaseContextProvider";
-export * from "./useAnalytics";
-export * from "./useRemoteConfig";
 export * from "./analytics";
 export * from "./auth";
+export * from "./context";
 export * from "./firestore";
 export * from "./remoteConfig";

package/src/remoteConfig/index.ts

@@ -1,2 +1,3 @@
 export * from "./useFetchAndActivate";
 export * from "./useGetValue";
+export * from "./useRemoteConfig";

package/src/remoteConfig/useFetchAndActivate.ts

@@ -1,16 +1,25 @@
-import { useRemoteConfig } from "../useRemoteConfig";
+import { useRemoteConfig } from "./useRemoteConfig";
 import { ensureInitialized, fetchAndActivate } from "firebase/remote-config";
 import { useCallback, useMemo, useState } from "react";
 
+/**
+ * Custom hook to fetch and activate remote configuration settings.
+ * Initializes remote configuration, fetches, activates it, and tracks the fetch status.
+ * @returns {Object} An object containing:
+ * - {Function} fetchAndActivate - Callback function to fetch and activate remote configuration.
+ * - {Boolean} isFetched - Boolean representing whether the fetch-and-activate process completed.
+ */
 export const useFetchAndActivate = () => {
     const remoteConfig = useRemoteConfig();
     const [isFetched, setIsFetched] = useState(false);
 
     const fetchAndActivateCallback = useCallback(async () => {
         try {
-            await ensureInitialized(remoteConfig);
-            await fetchAndActivate(remoteConfig);
-            setIsFetched(true);
+            if (remoteConfig) {
+                await ensureInitialized(remoteConfig);
+                await fetchAndActivate(remoteConfig);
+                setIsFetched(true);
+            }
         } catch (e) {
             setIsFetched(true);
             console.log(`Cannot read remote config: ${(e as Error)?.message}`);