react-query-firebase 1.0.0

package/dist/src/firestore/useDeleteDocMutation.js

@@ -0,0 +1,16 @@
+import { useMutation } from "@tanstack/react-query";
+import { deleteDoc } from "firebase/firestore";
+import { useMemo } from "react";
+export const useDeleteDocMutation = ({ reference, options = {} }) => {
+    const mutationKey = useMemo(() => [reference?.path], [reference?.path]);
+    return useMutation({
+        ...options,
+        mutationFn: async () => {
+            if (!reference) {
+                throw new Error("Reference is undefined");
+            }
+            await deleteDoc(reference);
+        },
+        mutationKey
+    });
+};

package/dist/src/firestore/useDocReference.d.ts

@@ -0,0 +1,7 @@
+import { CollectionReference, DocumentData, DocumentReference } from "firebase/firestore";
+export type UseDocReferenceOptions<AppModelType, DbModelType extends DocumentData = DocumentData> = {
+    reference?: CollectionReference<AppModelType, DbModelType> | DocumentReference<AppModelType, DbModelType>;
+    path?: string;
+    pathSegments?: string[];
+};
+export declare const useDocReference: <AppModelType, DbModelType extends DocumentData = DocumentData>({ path, reference, pathSegments }: UseDocReferenceOptions<AppModelType, DbModelType>) => DocumentReference<AppModelType, DbModelType> | null;

package/dist/src/firestore/useDocReference.js

@@ -0,0 +1,21 @@
+import { doc } from "firebase/firestore";
+import { useEffect, useRef } from "react";
+import { useFirestore } from "../useFirestore";
+const getDocReference = (db, { path, pathSegments, reference }) => {
+    if (!path) {
+        return null;
+    }
+    return (!reference
+        ? doc(db, path || "", ...(pathSegments || []))
+        : reference.type === "collection"
+            ? doc(reference, path, ...(pathSegments || []))
+            : doc(reference, path, ...(pathSegments || [])));
+};
+export const useDocReference = ({ path, reference, pathSegments }) => {
+    const db = useFirestore();
+    const ref = useRef(getDocReference(db, { path, pathSegments, reference }));
+    useEffect(() => {
+        ref.current = getDocReference(db, { path, pathSegments, reference });
+    }, [path, reference, pathSegments]);
+    return ref.current;
+};

package/dist/src/firestore/useDocReferences.d.ts

@@ -0,0 +1,7 @@
+import { CollectionReference, DocumentData, DocumentReference } from "firebase/firestore";
+export type UseDocReferencesOptions<AppModelType, DbModelType extends DocumentData = DocumentData> = {
+    reference?: CollectionReference<AppModelType, DbModelType> | DocumentReference<AppModelType, DbModelType>;
+    path: string;
+    pathSegments?: string[];
+};
+export declare const useDocReferences: <AppModelType, DbModelType extends DocumentData = DocumentData>(references: UseDocReferencesOptions<AppModelType, DbModelType>[]) => DocumentReference<AppModelType, DbModelType>[];

package/dist/src/firestore/useDocReferences.js

@@ -0,0 +1,15 @@
+import { doc } from "firebase/firestore";
+import { useMemo } from "react";
+import { useFirestore } from "../useFirestore";
+export const useDocReferences = (references) => {
+    const db = useFirestore();
+    return useMemo(() => {
+        return references.map(({ path, reference, pathSegments }) => {
+            return (!reference
+                ? doc(db, path || "", ...(pathSegments || []))
+                : reference.type === "collection"
+                    ? doc(reference, path, ...(pathSegments || []))
+                    : doc(reference, path, ...(pathSegments || [])));
+        });
+    }, [references]);
+};

package/dist/src/firestore/useGetDocData.d.ts

@@ -0,0 +1,10 @@
+import { CollectionReference, DocumentData, DocumentReference } from "firebase/firestore";
+import { UseQueryOptions } from "@tanstack/react-query";
+type UseGetDocOptions<AppModelType extends DocumentData = DocumentData, DbModelType extends DocumentData = DocumentData> = {
+    options: Omit<UseQueryOptions<AppModelType | null, Error, AppModelType>, "queryFn"> & Required<Pick<UseQueryOptions<AppModelType, Error, AppModelType>, "queryKey">>;
+    path?: string;
+    pathSegments?: string[];
+    reference: CollectionReference<AppModelType, DbModelType> | DocumentReference<AppModelType, DbModelType>;
+};
+export declare const useGetDocData: <AppModelType extends DocumentData = DocumentData, DbModelType extends DocumentData = DocumentData>({ options, reference, path, pathSegments }: UseGetDocOptions<AppModelType, DbModelType>) => import("@tanstack/react-query").UseQueryResult<AppModelType, Error>;
+export {};

package/dist/src/firestore/useGetDocData.js

@@ -0,0 +1,10 @@
+import { useFirestore } from "../useFirestore";
+import { getDocData } from "./utils/getDocData";
+import { useQuery } from "@tanstack/react-query";
+export const useGetDocData = ({ options, reference, path, pathSegments }) => {
+    const db = useFirestore();
+    return useQuery({
+        ...options,
+        queryFn: () => getDocData({ db, reference, path, pathSegments })
+    });
+};

package/dist/src/firestore/useInfiniteQuery.d.ts

@@ -0,0 +1,11 @@
+import { DocumentData, FirestoreDataConverter, Query, QueryCompositeFilterConstraint, QueryConstraint, QueryNonFilterConstraint } from "firebase/firestore";
+import { UseInfiniteQueryOptions as UseReactInfiniteQueryOptions, QueryKey, UseInfiniteQueryResult, InfiniteData } from "@tanstack/react-query";
+type UseInfiniteQueryOptions<AppModelType extends DocumentData = DocumentData, DbModelType extends DocumentData = DocumentData, TQueryKey extends QueryKey = QueryKey> = {
+    options: Omit<UseReactInfiniteQueryOptions<AppModelType[], Error, InfiniteData<AppModelType[]>, AppModelType[], TQueryKey, QueryConstraint>, "queryFn"> & Required<Pick<UseReactInfiniteQueryOptions<AppModelType[], Error, InfiniteData<AppModelType[]>, AppModelType[], TQueryKey, QueryConstraint>, "queryKey">>;
+    query: Query<AppModelType, DbModelType>;
+    queryConstraints?: QueryConstraint[] | QueryNonFilterConstraint[];
+    compositeFilter?: QueryCompositeFilterConstraint;
+    converter?: FirestoreDataConverter<AppModelType, DbModelType>;
+};
+export declare const useInfiniteQuery: <AppModelType extends DocumentData = DocumentData, DbModelType extends DocumentData = DocumentData>({ options, query: queryReference, queryConstraints, compositeFilter, converter }: UseInfiniteQueryOptions<AppModelType, DbModelType>) => UseInfiniteQueryResult<InfiniteData<AppModelType[]>>;
+export {};

package/dist/src/firestore/useInfiniteQuery.js

@@ -0,0 +1,21 @@
+import { getDocs, query } from "firebase/firestore";
+import { useInfiniteQuery as useInfiniteReactQuery } from "@tanstack/react-query";
+export const useInfiniteQuery = ({ options, query: queryReference, queryConstraints = [], compositeFilter, converter }) => {
+    return useInfiniteReactQuery({
+        ...options,
+        queryFn: async ({ pageParam }) => {
+            const allQueryConstraints = [...queryConstraints, ...(pageParam ? [pageParam] : [])];
+            const queryToExecute = compositeFilter
+                ? query(queryReference, compositeFilter, ...allQueryConstraints)
+                : query(queryReference, ...allQueryConstraints);
+            const querySnapshot = await getDocs(converter ? queryToExecute.withConverter(converter) : queryToExecute);
+            const docs = [];
+            if (querySnapshot) {
+                querySnapshot.forEach((doc) => {
+                    docs.push(doc.data());
+                });
+            }
+            return docs;
+        }
+    });
+};

package/dist/src/firestore/useQuery.d.ts

@@ -0,0 +1,11 @@
+import { DocumentData, FirestoreDataConverter, Query, QueryCompositeFilterConstraint, QueryConstraint, QueryNonFilterConstraint } from "firebase/firestore";
+import { UseQueryResult, UseQueryOptions as UseReactQueryOptions } from "@tanstack/react-query";
+type UseQueryOptions<AppModelType extends DocumentData = DocumentData, DbModelType extends DocumentData = DocumentData> = {
+    options: Omit<UseReactQueryOptions<AppModelType[], Error, AppModelType[]>, "queryFn"> & Required<Pick<UseReactQueryOptions<AppModelType[], Error, AppModelType[]>, "queryKey">>;
+    query: Query<AppModelType, DbModelType>;
+    queryConstraints?: QueryConstraint[] | QueryNonFilterConstraint[];
+    compositeFilter?: QueryCompositeFilterConstraint;
+    converter?: FirestoreDataConverter<AppModelType, DbModelType>;
+};
+export declare const useQuery: <AppModelType extends DocumentData = DocumentData, DbModelType extends DocumentData = DocumentData>({ options, query: queryReference, queryConstraints, compositeFilter, converter }: UseQueryOptions<AppModelType, DbModelType>) => UseQueryResult<AppModelType[]>;
+export {};

package/dist/src/firestore/useQuery.js

@@ -0,0 +1,20 @@
+import { getDocs, query } from "firebase/firestore";
+import { useQuery as useReactQuery } from "@tanstack/react-query";
+export const useQuery = ({ options, query: queryReference, queryConstraints = [], compositeFilter, converter }) => {
+    return useReactQuery({
+        ...options,
+        queryFn: async () => {
+            const queryToExecute = compositeFilter
+                ? query(queryReference, compositeFilter, ...queryConstraints)
+                : query(queryReference, ...queryConstraints);
+            const querySnapshot = await getDocs(converter ? queryToExecute.withConverter(converter) : queryToExecute);
+            const docs = [];
+            if (querySnapshot) {
+                querySnapshot.forEach((doc) => {
+                    docs.push(doc.data());
+                });
+            }
+            return docs;
+        }
+    });
+};

package/dist/src/firestore/useRunTransaction.d.ts

@@ -0,0 +1,8 @@
+import { UseMutationOptions } from "@tanstack/react-query";
+import { Transaction } from "firebase/firestore";
+import { FirebaseError } from "firebase/app";
+export type UseRunTransactionValues = <AppModelType = unknown>(transaction: Transaction) => AppModelType;
+export type UseRunTransactionOptions<AppModelType = unknown, TContext = unknown> = {
+    options?: Omit<UseMutationOptions<AppModelType, FirebaseError, UseRunTransactionValues, TContext>, "mutationFn">;
+};
+export declare const useRunTransaction: <AppModelType = unknown, TContext = unknown>({ options }: UseRunTransactionOptions<AppModelType, TContext>) => import("@tanstack/react-query").UseMutationResult<AppModelType, FirebaseError, UseRunTransactionValues, TContext>;

package/dist/src/firestore/useRunTransaction.js

@@ -0,0 +1,12 @@
+import { useMutation } from "@tanstack/react-query";
+import { runTransaction } from "firebase/firestore";
+import { useFirestore } from "../useFirestore";
+export const useRunTransaction = ({ options = {} }) => {
+    const db = useFirestore();
+    return useMutation({
+        ...options,
+        mutationFn: async (transactionFn) => {
+            return runTransaction(db, transactionFn);
+        }
+    });
+};

package/dist/src/firestore/useSetDocMutation.d.ts

@@ -0,0 +1,11 @@
+import { UseMutationOptions } from "@tanstack/react-query";
+import { DocumentData, DocumentReference, WithFieldValue } from "firebase/firestore";
+import { FirebaseError } from "firebase/app";
+export type UseSetDocMutationValues<AppModelType> = {
+    data: WithFieldValue<AppModelType>;
+};
+export type UseSetDocMutationOptions<AppModelType = unknown, DbModelType extends DocumentData = DocumentData, TContext = unknown> = {
+    reference: DocumentReference<AppModelType, DbModelType> | null;
+    options?: Omit<UseMutationOptions<void, FirebaseError, UseSetDocMutationValues<AppModelType>, TContext>, "mutationFn" | "mutationKey">;
+};
+export declare const useSetDocMutation: <AppModelType = unknown, DbModelType extends DocumentData = DocumentData, TContext = unknown>({ reference, options }: UseSetDocMutationOptions<AppModelType, DbModelType, TContext>) => import("@tanstack/react-query").UseMutationResult<void, FirebaseError, UseSetDocMutationValues<AppModelType>, TContext>;

package/dist/src/firestore/useSetDocMutation.js

@@ -0,0 +1,16 @@
+import { useMutation } from "@tanstack/react-query";
+import { setDoc } from "firebase/firestore";
+import { useMemo } from "react";
+export const useSetDocMutation = ({ reference, options }) => {
+    const mutationKey = useMemo(() => [reference?.path], [reference?.path]);
+    return useMutation({
+        ...options,
+        mutationFn: ({ data }) => {
+            if (!reference) {
+                throw new Error("Reference is undefined");
+            }
+            return setDoc(reference, data);
+        },
+        mutationKey
+    });
+};

package/dist/src/firestore/useUpdateDocMutation.d.ts

@@ -0,0 +1,12 @@
+import { UseMutationOptions } from "@tanstack/react-query";
+import { DocumentData, FirestoreDataConverter, DocumentReference, UpdateData } from "firebase/firestore";
+import { FirebaseError } from "firebase/app";
+export type UseUpdateDocMutationValues<DbModelType> = {
+    data: UpdateData<DbModelType>;
+};
+export type UseUpdateDocMutationOptions<AppModelType extends DocumentData = DocumentData, DbModelType extends DocumentData = DocumentData, TContext = unknown> = {
+    reference: DocumentReference<AppModelType, DbModelType> | null;
+    converter?: FirestoreDataConverter<AppModelType, DbModelType>;
+    options?: Omit<UseMutationOptions<AppModelType, FirebaseError, UseUpdateDocMutationValues<DbModelType>, TContext>, "mutationFn" | "mutationKey">;
+};
+export declare const useUpdateDocMutation: <AppModelType extends DocumentData = DocumentData, DbModelType extends DocumentData = DocumentData, TContext = unknown>({ reference, converter, options }: UseUpdateDocMutationOptions<AppModelType, DbModelType, TContext>) => import("@tanstack/react-query").UseMutationResult<AppModelType, FirebaseError, UseUpdateDocMutationValues<DbModelType>, TContext>;

package/dist/src/firestore/useUpdateDocMutation.js

@@ -0,0 +1,18 @@
+import { useMutation } from "@tanstack/react-query";
+import { updateDoc, getDoc } from "firebase/firestore";
+import { useMemo } from "react";
+export const useUpdateDocMutation = ({ reference, converter, options = {} }) => {
+    const mutationKey = useMemo(() => [reference?.path], [reference?.path]);
+    return useMutation({
+        ...options,
+        mutationFn: async ({ data }) => {
+            if (!reference) {
+                throw new Error("Reference is undefined");
+            }
+            await updateDoc(reference, data);
+            const docSnap = await getDoc(converter ? reference.withConverter(converter) : reference);
+            return docSnap.data();
+        },
+        mutationKey
+    });
+};

package/dist/src/firestore/utils/getDocData.d.ts

@@ -0,0 +1,4 @@
+import { DocumentData } from "firebase/firestore";
+import { GetDocSnapOptions } from "./getDocSnap";
+export type GetDocDataOptions<AppModelType extends DocumentData = DocumentData, DbModelType extends DocumentData = DocumentData> = GetDocSnapOptions<AppModelType, DbModelType>;
+export declare const getDocData: <AppModelType extends DocumentData = DocumentData, DbModelType extends DocumentData = DocumentData>({ db, reference, path, pathSegments }: GetDocDataOptions<AppModelType, DbModelType>) => Promise<AppModelType | null>;

package/dist/src/firestore/utils/getDocData.js

@@ -0,0 +1,8 @@
+import { getDocSnap } from "./getDocSnap";
+export const getDocData = async ({ db, reference, path, pathSegments }) => {
+    const docSnap = await getDocSnap({ db, reference, path, pathSegments });
+    if (docSnap && docSnap.exists()) {
+        return docSnap.data();
+    }
+    return null;
+};

package/dist/src/firestore/utils/getDocRef.d.ts

@@ -0,0 +1,8 @@
+import { CollectionReference, DocumentData, DocumentReference, Firestore } from "firebase/firestore";
+export type GetDocRefOptions<AppModelType extends DocumentData = DocumentData, DbModelType extends DocumentData = DocumentData> = {
+    db: Firestore;
+    reference?: CollectionReference<AppModelType, DbModelType> | DocumentReference<AppModelType, DbModelType>;
+    path?: string;
+    pathSegments?: string[];
+};
+export declare const getDocRef: <AppModelType extends DocumentData = DocumentData, DbModelType extends DocumentData = DocumentData>({ db, reference, path, pathSegments }: GetDocRefOptions<AppModelType, DbModelType>) => Promise<DocumentReference<AppModelType, DbModelType>>;

package/dist/src/firestore/utils/getDocRef.js

@@ -0,0 +1,14 @@
+import { doc } from "firebase/firestore";
+export const getDocRef = async ({ db, reference, path, pathSegments }) => {
+    if (!reference && !path) {
+        throw new Error("One of the options must be provided: path or reference.");
+    }
+    const docRef = !reference
+        ? doc(db, path, ...(pathSegments || []))
+        : reference.type === "collection"
+            ? doc(reference, path, ...(pathSegments || []))
+            : reference.type === "document"
+                ? doc(reference, path, ...(pathSegments || []))
+                : null;
+    return docRef;
+};

package/dist/src/firestore/utils/getDocSnap.d.ts

@@ -0,0 +1,4 @@
+import { DocumentData } from "firebase/firestore";
+import { GetDocRefOptions } from "./getDocRef";
+export type GetDocSnapOptions<AppModelType extends DocumentData = DocumentData, DbModelType extends DocumentData = DocumentData> = GetDocRefOptions<AppModelType, DbModelType>;
+export declare const getDocSnap: <AppModelType extends DocumentData = DocumentData, DbModelType extends DocumentData = DocumentData>({ db, reference, path, pathSegments }: GetDocSnapOptions<AppModelType, DbModelType>) => Promise<import("@firebase/firestore").DocumentSnapshot<AppModelType, DbModelType> | null>;

package/dist/src/firestore/utils/getDocSnap.js

@@ -0,0 +1,9 @@
+import { getDoc as firestoreGetDoc } from "firebase/firestore";
+import { getDocRef } from "./getDocRef";
+export const getDocSnap = async ({ db, reference, path, pathSegments }) => {
+    const docRef = await getDocRef({ db, reference, path, pathSegments });
+    if (docRef) {
+        return await firestoreGetDoc(docRef);
+    }
+    return null;
+};

package/dist/src/index.d.ts

@@ -0,0 +1,10 @@
+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 "./firestore";
+export * from "./remoteConfig";

package/dist/src/index.js

@@ -0,0 +1,10 @@
+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 "./firestore";
+export * from "./remoteConfig";

package/dist/src/remoteConfig/index.d.ts

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

package/dist/src/remoteConfig/index.js

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

package/dist/src/remoteConfig/useFetchAndActivate.d.ts

@@ -0,0 +1,4 @@
+export declare const useFetchAndActivate: () => {
+    fetchAndActivate: () => Promise<void>;
+    isFetched: boolean;
+};

package/dist/src/remoteConfig/useFetchAndActivate.js

@@ -0,0 +1,22 @@
+import { useRemoteConfig } from "../useRemoteConfig";
+import { ensureInitialized, fetchAndActivate } from "firebase/remote-config";
+import { useCallback, useMemo, useState } from "react";
+export const useFetchAndActivate = () => {
+    const remoteConfig = useRemoteConfig();
+    const [isFetched, setIsFetched] = useState(false);
+    const fetchAndActivateCallback = useCallback(async () => {
+        try {
+            await ensureInitialized(remoteConfig);
+            await fetchAndActivate(remoteConfig);
+            setIsFetched(true);
+        }
+        catch (e) {
+            setIsFetched(true);
+            console.log(`Cannot read remote config: ${e?.message}`);
+        }
+    }, [isFetched]);
+    return useMemo(() => ({
+        fetchAndActivate: fetchAndActivateCallback,
+        isFetched
+    }), [isFetched, fetchAndActivateCallback]);
+};

package/dist/src/remoteConfig/useGetValue.d.ts

@@ -0,0 +1 @@
+export declare const useGetValue: (key: string) => import("@firebase/remote-config").Value | null;

package/dist/src/remoteConfig/useGetValue.js

@@ -0,0 +1,9 @@
+import { getValue } from "firebase/remote-config";
+import { useRemoteConfig } from "../useRemoteConfig";
+import { useMemo } from "react";
+export const useGetValue = (key) => {
+    const remoteConfig = useRemoteConfig();
+    return useMemo(() => {
+        return remoteConfig ? getValue(remoteConfig, key) : null;
+    }, [remoteConfig?.lastFetchStatus, key]);
+};

package/dist/src/useAnalytics.d.ts

@@ -0,0 +1 @@
+export declare const useAnalytics: () => import("@firebase/analytics").Analytics;

package/dist/src/useAnalytics.js

@@ -0,0 +1,6 @@
+import { useContext } from "react";
+import { FirebaseContext } from "./FirebaseContext";
+export const useAnalytics = () => {
+    const { analytics } = useContext(FirebaseContext);
+    return analytics;
+};

package/dist/src/useAuth.d.ts

@@ -0,0 +1 @@
+export declare const useAuth: () => import("firebase/auth").Auth;

package/dist/src/useAuth.js

@@ -0,0 +1,6 @@
+import { useContext } from "react";
+import { FirebaseContext } from "./FirebaseContext";
+export const useAuth = () => {
+    const { auth } = useContext(FirebaseContext);
+    return auth;
+};

package/dist/src/useFirebase.d.ts

@@ -0,0 +1 @@
+export declare const useFirebase: () => import("@firebase/app").FirebaseApp;

package/dist/src/useFirebase.js

@@ -0,0 +1,6 @@
+import { useContext } from "react";
+import { FirebaseContext } from "./FirebaseContext";
+export const useFirebase = () => {
+    const { firebase } = useContext(FirebaseContext);
+    return firebase;
+};

package/dist/src/useFirestore.d.ts

@@ -0,0 +1 @@
+export declare const useFirestore: () => import("@firebase/firestore").Firestore;

package/dist/src/useFirestore.js

@@ -0,0 +1,6 @@
+import { useContext } from "react";
+import { FirebaseContext } from "./FirebaseContext";
+export const useFirestore = () => {
+    const { firestore } = useContext(FirebaseContext);
+    return firestore;
+};

package/dist/src/useRemoteConfig.d.ts

@@ -0,0 +1 @@
+export declare const useRemoteConfig: () => import("@firebase/remote-config").RemoteConfig;

package/dist/src/useRemoteConfig.js

@@ -0,0 +1,6 @@
+import { useContext } from "react";
+import { FirebaseContext } from "./FirebaseContext";
+export const useRemoteConfig = () => {
+    const { remoteConfig } = useContext(FirebaseContext);
+    return remoteConfig;
+};

package/package.json

@@ -0,0 +1,57 @@
+{
+    "author": "Victor Pishuk <victor.pishuk@gmail.com>",
+    "type": "module",
+    "bugs": {
+        "url": "https://github.com/vpishuk/react-query-firebase/issues"
+    },
+    "dependencies": {
+        "firebase": "^11.0.1"
+    },
+    "peerDependencies": {
+        "react": "^19.0.0",
+        "@tanstack/react-query": "^5.62.15"
+    },
+    "publishConfig": {
+        "access": "public"
+    },
+    "description": "This module offers react hooks to work with Firebase",
+    "devDependencies": {
+        "@laverve/eslint-utils": "^5.1.1",
+        "@types/react": "^19.0.2",
+        "husky": "^9.1.1",
+        "lint-staged": "^15.1.0",
+        "prettier": "^3.0.3",
+        "react": "^19.0.0",
+        "typescript": "^5.2.2"
+    },
+    "homepage": "https://github.com/vpishuk/react-query-firebase",
+    "keywords": [
+        "firebase",
+        "react",
+        "hooks"
+    ],
+    "license": "MIT",
+    "main": "./dist/src/index.js",
+    "types": "./dist/src/index.d.ts",
+    "name": "react-query-firebase",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/vpishuk/react-query-firebase.git"
+    },
+    "files": [
+        "./dist/src/",
+        "./src/",
+        "package.json",
+        "package-lock.json",
+        "README.md",
+        "LICENSE"
+    ],
+    "scripts": {
+        "build": "rm -rf ./dist/ && tsc -p tsconfig.build.json",
+        "lint": "eslint",
+        "lint:fix": "eslint  --fix",
+        "lint:staged": "lint-staged",
+        "prepare": "husky"
+    },
+    "version": "1.0.0"
+}

package/src/FirebaseContext.ts

@@ -0,0 +1,18 @@
+"use client";
+import { createContext } from "react";
+
+import { Auth } from "firebase/auth";
+import { Analytics } from "firebase/analytics";
+import { Firestore } from "firebase/firestore";
+import { FirebaseApp } from "firebase/app";
+import { RemoteConfig } from "firebase/remote-config";
+
+export type FirebaseContextValue = {
+    auth: Auth;
+    analytics: Analytics;
+    firebase: FirebaseApp;
+    remoteConfig: RemoteConfig;
+    firestore: Firestore;
+};
+
+export const FirebaseContext = createContext<Partial<FirebaseContextValue>>({});

package/src/FirebaseContextProvider.tsx

@@ -0,0 +1,91 @@
+import React, { PropsWithChildren, useMemo } from "react";
+import { FirebaseContext, FirebaseContextValue } 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";
+
+type FirestorEmulatorConfig = {
+    host: string;
+    port: number;
+};
+
+type AuthEmulatorConfig = {
+    host: string;
+};
+
+type Emulators = {
+    firestore?: FirestorEmulatorConfig;
+    auth?: AuthEmulatorConfig;
+};
+
+type FirebaseContextProvider = PropsWithChildren & {
+    emulators?: Emulators;
+    options: FirebaseOptions;
+    authEnabled?: boolean;
+    analyticsEnabled?: boolean;
+    firestoreEnabled?: boolean;
+    remoteConfigSettings?: RemoteConfigSettings;
+    remoteConfigDefaults?: { [key: string]: string | number | boolean };
+    remoteConfigEnabled?: boolean;
+};
+
+export const FirebaseContextProvider: React.FC<FirebaseContextProvider> = ({
+    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<FirebaseContextValue> = {};
+
+        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}>{children}</FirebaseContext.Provider>;
+};

package/src/analytics/index.ts

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