@reause/firebase 0.1.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 hairyf
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+import { UseAuthOptions, UseAuthReturn, useAuth } from "./useAuth.js";
+import { FirebaseDocRef, UseFirestoreOptions, useFirestore } from "./useFirestore.js";
+import { UseRTDBOptions, UseRTDBReturn, useRTDB } from "./useRTDB.js";
+export { FirebaseDocRef, UseAuthOptions, UseAuthReturn, UseFirestoreOptions, UseRTDBOptions, UseRTDBReturn, useAuth, useFirestore, useRTDB };

package/dist/index.iife.js

@@ -0,0 +1,267 @@
+(function(exports, react, _reause_shared, firebase_database) {
+	Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+	//#region useAuth/index.tsx
+	/**
+	* React port of VueUse's `useAuth`.
+	*
+	* Map from @vueuse/firebase/useAuth
+	* (`source/vueuse/packages/firebase/useAuth/`). Reactive
+	* [Firebase Auth](https://firebase.google.com/docs/auth) binding — it exposes
+	* the current `user` and an `isAuthenticated` flag, so a component can react to
+	* sign-in, sign-out and ID-token refresh events.
+	*
+	* Adjustment for React:
+	* - the `Auth` instance stays the first argument (`useAuth(auth)`), but the
+	*   return is a plain object `{ isAuthenticated, user, loading, error }` — the
+	*   values are read during render instead of being Vue refs (`ComputedRef`
+	*   / `Ref`), and the object is returned rather than a destructured tuple;
+	* - `loading` and `error` are additions to upstream. Firebase reports the
+	*   current auth state **asynchronously**, so a port without `loading` would
+	*   render the signed-out UI for one frame before the listener corrects it;
+	*   `loading` starts `true` and flips to `false` with the first callback (a
+	*   signed-out callback included). `error` stays `null` unless subscribing
+	*   itself throws;
+	* - `user` is seeded from `auth.currentUser` (upstream's
+	*   `ref(auth.currentUser)`), so an already signed-in visitor renders
+	*   authenticated on the very first pass, while `loading` is still `true`;
+	* - upstream subscribes in `setup()` and **never** unsubscribes; this port
+	*   subscribes in an effect keyed on `auth` and returns the listener's
+	*   `Unsubscribe` as cleanup, so a new `Auth` instance re-subscribes (and
+	*   re-seeds `user`/`loading`/`error`) and unmounting stops the listener — a
+	*   deliberate React-idiomatic deviation that fixes upstream's leak;
+	* - errors on sign-in/sign-out are **not** routed here: the `error` and
+	*   `completed` callbacks of `onIdTokenChanged` are deprecated in Firebase and
+	*   documented as never firing. Catch those on the promise returned by
+	*   `signInWithPopup` / `signOut` itself; `error` only reports a subscription
+	*   that could not be established;
+	* - the latest `errorHandler` is read from a ref, so passing an inline handler
+	*   does not re-subscribe;
+	* - nothing runs while rendering, so server rendering is safe.
+	*
+	* @see https://vueuse.org/firebase/useAuth/
+	*
+	* @example
+	* const auth = getAuth(app)
+	* const { isAuthenticated, user, loading, error } = useAuth(auth)
+	* if (loading) return <div>Loading...</div>
+	* if (!isAuthenticated) return <div>Please log in</div>
+	* return <div>Welcome, {user.displayName}</div>
+	*
+	* @__NO_SIDE_EFFECTS__
+	*/
+	function useAuth(auth, options = {}) {
+		const { errorHandler = (err) => console.error(err) } = options;
+		const [user, setUser] = (0, react.useState)(() => auth.currentUser);
+		const [loading, setLoading] = (0, react.useState)(true);
+		const [error, setError] = (0, react.useState)(null);
+		const errorHandlerRef = (0, react.useRef)(errorHandler);
+		(0, react.useEffect)(() => {
+			errorHandlerRef.current = errorHandler;
+		}, [errorHandler]);
+		const subscribedAuthRef = (0, react.useRef)(auth);
+		(0, react.useEffect)(() => {
+			if (subscribedAuthRef.current !== auth) {
+				subscribedAuthRef.current = auth;
+				setUser(auth.currentUser);
+				setLoading(true);
+				setError(null);
+			}
+			let unsubscribe;
+			let active = true;
+			try {
+				unsubscribe = auth.onIdTokenChanged((authUser) => {
+					if (!active) return;
+					setUser(authUser);
+					setLoading(false);
+				});
+			} catch (err) {
+				const subscriptionError = err instanceof Error ? err : new Error(String(err));
+				setError(subscriptionError);
+				setLoading(false);
+				errorHandlerRef.current(subscriptionError);
+			}
+			return () => {
+				active = false;
+				unsubscribe === null || unsubscribe === void 0 || unsubscribe();
+			};
+		}, [auth]);
+		return {
+			isAuthenticated: user !== null,
+			user,
+			loading,
+			error
+		};
+	}
+	//#endregion
+	//#region useFirestore/index.tsx
+	/**
+	* Attach the document `id` as a non-writable property of the snapshot data —
+	* ported verbatim from upstream. `data()` may be `undefined` for a deleted
+	* document.
+	*/
+	function getData(docRef) {
+		const data = docRef.data();
+		if (data) Object.defineProperty(data, "id", {
+			value: docRef.id.toString(),
+			writable: false
+		});
+		return data;
+	}
+	/**
+	* Slash-parity check, ported verbatim from upstream: a `DocumentReference`
+	* path has an odd number of segments (`users/ada`), a `Query` path an even
+	* number (`users` or `users/ada/posts`).
+	*/
+	function isDocumentReference(docRef) {
+		var _docRef$path;
+		return (((_docRef$path = docRef.path) === null || _docRef$path === void 0 ? void 0 : _docRef$path.match(/\//g)) || []).length % 2 !== 0;
+	}
+	/**
+	* React port of VueUse's `useFirestore`.
+	*
+	* Map from @vueuse/firebase/useFirestore
+	* (`source/vueuse/packages/firebase/useFirestore/`). Reactive
+	* [Firestore](https://firebase.google.com/docs/firestore) binding — it keeps
+	* local state in sync with a document reference or a query, so a component
+	* always renders the freshest remote data.
+	*
+	* Adjustment for React:
+	* - `maybeDocRef` is a plain value (upstream accepts `MaybeRef`): read-only
+	*   value-source parameters take plain `T`. Pass a new reference/query
+	*   identity to re-subscribe — **keep it stable across renders** (memoize
+	*   `doc`/`collection`/`query` results): a fresh identity on every render
+	*   re-subscribes on every render;
+	* - the return is the plain state VALUE (not a tuple, not an object) —
+	*   upstream exposes no setter (0 writable values), so the shape mirrors the
+	*   read side of upstream's `Ref<T | null>` / `Ref<T[]>`; a document resolves
+	*   to `T | null` (a deleted document becomes `null`), a query to `T[]`;
+	* - the subscription lives in an effect keyed on `maybeDocRef`, so a new
+	*   ref/query identity re-subscribes and closes the previous `onSnapshot`
+	*   (upstream's immediate watch); a falsy docRef resets `data` to
+	*   `initialValue`;
+	* - `firebase/firestore` is loaded through a guarded **dynamic** import, so
+	*   this module never throws at import time when `firebase` is missing — a
+	*   missing module or a failed `onSnapshot` call surfaces through
+	*   `errorHandler` instead, and `data` stays at `initialValue`;
+	* - the latest `errorHandler` is read from a ref, so passing an inline handler
+	*   does not re-subscribe;
+	* - nothing runs while rendering, so server rendering is safe.
+	*
+	* @see https://vueuse.org/firebase/useFirestore/
+	*
+	* @example
+	* const todos = useFirestore(collection(db, 'todos'))
+	* const user = useFirestore(doc(db, 'users', 'my-user-id'))
+	*
+	* @__NO_SIDE_EFFECTS__
+	*/
+	function useFirestore(maybeDocRef, initialValue = void 0, options = {}) {
+		const { errorHandler = (err) => console.error(err), autoDispose = true } = options;
+		const [data, setData] = (0, react.useState)(initialValue);
+		const initialValueRef = (0, react.useRef)(initialValue);
+		const autoDisposeRef = (0, react.useRef)(autoDispose);
+		const errorHandlerRef = (0, react.useRef)(errorHandler);
+		(0, react.useEffect)(() => {
+			errorHandlerRef.current = errorHandler;
+		}, [errorHandler]);
+		const closeRef = (0, react.useRef)(() => {});
+		(0, react.useEffect)(() => {
+			closeRef.current();
+			closeRef.current = () => {};
+			if (!maybeDocRef) {
+				setData(initialValueRef.current);
+				return;
+			}
+			let active = true;
+			let close;
+			import("firebase/firestore").then(({ onSnapshot }) => {
+				if (!active) return;
+				try {
+					var _close;
+					if (isDocumentReference(maybeDocRef)) close = onSnapshot(maybeDocRef, (snapshot) => {
+						if (!active) return;
+						setData(getData(snapshot) || null);
+					}, (err) => errorHandlerRef.current(err));
+					else close = onSnapshot(maybeDocRef, (snapshot) => {
+						if (!active) return;
+						setData(snapshot.docs.map(getData).filter(_reause_shared.isDef));
+					}, (err) => errorHandlerRef.current(err));
+					closeRef.current = (_close = close) !== null && _close !== void 0 ? _close : (() => {});
+				} catch (err) {
+					errorHandlerRef.current(err instanceof Error ? err : new Error(String(err)));
+				}
+			}).catch((err) => {
+				if (!active) return;
+				errorHandlerRef.current(err instanceof Error ? err : new Error(String(err)));
+			});
+			return () => {
+				active = false;
+			};
+		}, [maybeDocRef]);
+		(0, react.useEffect)(() => {
+			return () => {
+				if (autoDisposeRef.current === true) closeRef.current();
+				else if (typeof autoDisposeRef.current === "number") setTimeout(() => {
+					closeRef.current();
+				}, autoDisposeRef.current);
+			};
+		}, []);
+		return data;
+	}
+	//#endregion
+	//#region useRTDB/index.tsx
+	/**
+	* React port of VueUse's `useRTDB`.
+	*
+	* Map from @vueuse/firebase `useRTDB`
+	*
+	* Reactive [Firebase Realtime Database](https://firebase.google.com/docs/database)
+	* binding — keeps local state in sync with a database reference. The listener
+	* is registered with `onValue` in a mount effect and feeds `data` with
+	* `snapshot.val()` on every database change.
+	*
+	* Adjustment for React:
+	* - upstream returns a writable `Ref<T | undefined>`, so this port returns the
+	*   `[data, setData]` tuple; `data` starts `undefined` and holds the latest
+	*   snapshot value;
+	* - `setData` writes **local state only** — it does not write to the Realtime
+	*   Database (upstream's ref is equally local). Use the `firebase/database`
+	*   write APIs (`set` / `update` / `push`) to persist;
+	* - the subscription lives in a `useEffect` keyed on `docRef` and `autoDispose`,
+	*   so a new `docRef` identity re-subscribes and unsubscribes the previous
+	*   listener (upstream subscribes once per `setup()` — a deliberate
+	*   React-idiomatic deviation);
+	* - cleanup calls the `onValue` unsubscribe only when `autoDispose` is `true`
+	*   (upstream parity). `autoDispose: false` means the subscription outlives the
+	*   component: the caller gets no `off` handle and must live with the leak —
+	*   discouraged, kept only for upstream parity;
+	* - the latest `errorHandler` is read from a ref, so passing an inline handler
+	*   does not re-subscribe.
+	*
+	* @see https://vueuse.org/useRTDB
+	*
+	* @example
+	* const [todos, setTodos] = useRTDB<Record<string, Todo>>(ref(getDatabase(app), 'todos'))
+	*
+	* @__NO_SIDE_EFFECTS__
+	*/
+	function useRTDB(docRef, options = {}) {
+		const { errorHandler = (err) => console.error(err), autoDispose = true } = options;
+		const [data, setData] = (0, react.useState)(void 0);
+		const errorHandlerRef = (0, react.useRef)(errorHandler);
+		(0, react.useEffect)(() => {
+			errorHandlerRef.current = errorHandler;
+		}, [errorHandler]);
+		(0, react.useEffect)(() => {
+			const off = (0, firebase_database.onValue)(docRef, (snapshot) => setData(snapshot.val()), (err) => errorHandlerRef.current(err));
+			return () => {
+				if (autoDispose) off();
+			};
+		}, [docRef, autoDispose]);
+		return [data, setData];
+	}
+	//#endregion
+	exports.useAuth = useAuth;
+	exports.useFirestore = useFirestore;
+	exports.useRTDB = useRTDB;
+})(this.reause = this.reause || {}, React, reause, firebase);

package/dist/index.iife.min.js

@@ -0,0 +1 @@
+(function(e,t,n,r){Object.defineProperty(e,Symbol.toStringTag,{value:`Module`});function i(e,n={}){let{errorHandler:r=e=>console.error(e)}=n,[i,a]=(0,t.useState)(()=>e.currentUser),[o,s]=(0,t.useState)(!0),[c,l]=(0,t.useState)(null),u=(0,t.useRef)(r);(0,t.useEffect)(()=>{u.current=r},[r]);let d=(0,t.useRef)(e);return(0,t.useEffect)(()=>{d.current!==e&&(d.current=e,a(e.currentUser),s(!0),l(null));let t,n=!0;try{t=e.onIdTokenChanged(e=>{n&&(a(e),s(!1))})}catch(e){let t=e instanceof Error?e:Error(String(e));l(t),s(!1),u.current(t)}return()=>{n=!1,t==null||t()}},[e]),{isAuthenticated:i!==null,user:i,loading:o,error:c}}function a(e){let t=e.data();return t&&Object.defineProperty(t,"id",{value:e.id.toString(),writable:!1}),t}function o(e){var t;return(((t=e.path)==null?void 0:t.match(/\//g))||[]).length%2!=0}function s(e,r=void 0,i={}){let{errorHandler:s=e=>console.error(e),autoDispose:c=!0}=i,[l,u]=(0,t.useState)(r),d=(0,t.useRef)(r),f=(0,t.useRef)(c),p=(0,t.useRef)(s);(0,t.useEffect)(()=>{p.current=s},[s]);let m=(0,t.useRef)(()=>{});return(0,t.useEffect)(()=>{if(m.current(),m.current=()=>{},!e){u(d.current);return}let t=!0,r;return import(`firebase/firestore`).then(({onSnapshot:i})=>{if(t)try{var s;r=o(e)?i(e,e=>{t&&u(a(e)||null)},e=>p.current(e)):i(e,e=>{t&&u(e.docs.map(a).filter(n.isDef))},e=>p.current(e)),m.current=(s=r)==null?(()=>{}):s}catch(e){p.current(e instanceof Error?e:Error(String(e)))}}).catch(e=>{t&&p.current(e instanceof Error?e:Error(String(e)))}),()=>{t=!1}},[e]),(0,t.useEffect)(()=>()=>{f.current===!0?m.current():typeof f.current==`number`&&setTimeout(()=>{m.current()},f.current)},[]),l}function c(e,n={}){let{errorHandler:i=e=>console.error(e),autoDispose:a=!0}=n,[o,s]=(0,t.useState)(void 0),c=(0,t.useRef)(i);return(0,t.useEffect)(()=>{c.current=i},[i]),(0,t.useEffect)(()=>{let t=(0,r.onValue)(e,e=>s(e.val()),e=>c.current(e));return()=>{a&&t()}},[e,a]),[o,s]}e.useAuth=i,e.useFirestore=s,e.useRTDB=c})(this.reause=this.reause||{},React,reause,firebase);

package/dist/index.js

@@ -0,0 +1,4 @@
+import { useAuth } from "./useAuth.js";
+import { useFirestore } from "./useFirestore.js";
+import { useRTDB } from "./useRTDB.js";
+export { useAuth, useFirestore, useRTDB };

package/dist/useAuth.d.ts

@@ -0,0 +1,87 @@
+import { Auth, User } from "firebase/auth";
+//#region useAuth/index.d.ts
+export interface UseAuthOptions {
+  /**
+   * Custom error handler for auth subscription errors.
+   *
+   * @default (error) => console.error(error)
+   */
+  errorHandler?: (err: Error) => void;
+}
+/**
+ * Result object of `useAuth` — the plain-value counterpart of upstream's
+ * `{ isAuthenticated, user }` refs, plus the `loading` and `error` states.
+ */
+export interface UseAuthReturn {
+  /**
+   * Whether a user is currently authenticated (upstream's `isAuthenticated`
+   * computed): `true` whenever `user` is not `null`.
+   */
+  isAuthenticated: boolean;
+  /**
+   * The current Firebase user, or `null` if not authenticated (upstream's
+   * `user` ref). Seeded from `auth.currentUser` and kept in sync by
+   * `onIdTokenChanged`.
+   */
+  user: User | null;
+  /**
+   * Whether the auth state is still being resolved: `true` on the first render
+   * and until `onIdTokenChanged` reports the current state (or the subscription
+   * fails), then `false` — including when the reported state is signed out.
+   */
+  loading: boolean;
+  /**
+   * The error thrown while subscribing to `auth.onIdTokenChanged`, or `null`.
+   */
+  error: Error | null;
+}
+/**
+ * React port of VueUse's `useAuth`.
+ *
+ * Map from @vueuse/firebase/useAuth
+ * (`source/vueuse/packages/firebase/useAuth/`). Reactive
+ * [Firebase Auth](https://firebase.google.com/docs/auth) binding — it exposes
+ * the current `user` and an `isAuthenticated` flag, so a component can react to
+ * sign-in, sign-out and ID-token refresh events.
+ *
+ * Adjustment for React:
+ * - the `Auth` instance stays the first argument (`useAuth(auth)`), but the
+ *   return is a plain object `{ isAuthenticated, user, loading, error }` — the
+ *   values are read during render instead of being Vue refs (`ComputedRef`
+ *   / `Ref`), and the object is returned rather than a destructured tuple;
+ * - `loading` and `error` are additions to upstream. Firebase reports the
+ *   current auth state **asynchronously**, so a port without `loading` would
+ *   render the signed-out UI for one frame before the listener corrects it;
+ *   `loading` starts `true` and flips to `false` with the first callback (a
+ *   signed-out callback included). `error` stays `null` unless subscribing
+ *   itself throws;
+ * - `user` is seeded from `auth.currentUser` (upstream's
+ *   `ref(auth.currentUser)`), so an already signed-in visitor renders
+ *   authenticated on the very first pass, while `loading` is still `true`;
+ * - upstream subscribes in `setup()` and **never** unsubscribes; this port
+ *   subscribes in an effect keyed on `auth` and returns the listener's
+ *   `Unsubscribe` as cleanup, so a new `Auth` instance re-subscribes (and
+ *   re-seeds `user`/`loading`/`error`) and unmounting stops the listener — a
+ *   deliberate React-idiomatic deviation that fixes upstream's leak;
+ * - errors on sign-in/sign-out are **not** routed here: the `error` and
+ *   `completed` callbacks of `onIdTokenChanged` are deprecated in Firebase and
+ *   documented as never firing. Catch those on the promise returned by
+ *   `signInWithPopup` / `signOut` itself; `error` only reports a subscription
+ *   that could not be established;
+ * - the latest `errorHandler` is read from a ref, so passing an inline handler
+ *   does not re-subscribe;
+ * - nothing runs while rendering, so server rendering is safe.
+ *
+ * @see https://vueuse.org/firebase/useAuth/
+ *
+ * @example
+ * const auth = getAuth(app)
+ * const { isAuthenticated, user, loading, error } = useAuth(auth)
+ * if (loading) return <div>Loading...</div>
+ * if (!isAuthenticated) return <div>Please log in</div>
+ * return <div>Welcome, {user.displayName}</div>
+ *
+ * @__NO_SIDE_EFFECTS__
+ */
+export declare function useAuth(auth: Auth, options?: UseAuthOptions): UseAuthReturn;
+//#endregion

package/dist/useAuth.iife.js

@@ -0,0 +1,97 @@
+(function(exports, react) {
+	Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+	//#region useAuth/index.tsx
+	/**
+	* React port of VueUse's `useAuth`.
+	*
+	* Map from @vueuse/firebase/useAuth
+	* (`source/vueuse/packages/firebase/useAuth/`). Reactive
+	* [Firebase Auth](https://firebase.google.com/docs/auth) binding — it exposes
+	* the current `user` and an `isAuthenticated` flag, so a component can react to
+	* sign-in, sign-out and ID-token refresh events.
+	*
+	* Adjustment for React:
+	* - the `Auth` instance stays the first argument (`useAuth(auth)`), but the
+	*   return is a plain object `{ isAuthenticated, user, loading, error }` — the
+	*   values are read during render instead of being Vue refs (`ComputedRef`
+	*   / `Ref`), and the object is returned rather than a destructured tuple;
+	* - `loading` and `error` are additions to upstream. Firebase reports the
+	*   current auth state **asynchronously**, so a port without `loading` would
+	*   render the signed-out UI for one frame before the listener corrects it;
+	*   `loading` starts `true` and flips to `false` with the first callback (a
+	*   signed-out callback included). `error` stays `null` unless subscribing
+	*   itself throws;
+	* - `user` is seeded from `auth.currentUser` (upstream's
+	*   `ref(auth.currentUser)`), so an already signed-in visitor renders
+	*   authenticated on the very first pass, while `loading` is still `true`;
+	* - upstream subscribes in `setup()` and **never** unsubscribes; this port
+	*   subscribes in an effect keyed on `auth` and returns the listener's
+	*   `Unsubscribe` as cleanup, so a new `Auth` instance re-subscribes (and
+	*   re-seeds `user`/`loading`/`error`) and unmounting stops the listener — a
+	*   deliberate React-idiomatic deviation that fixes upstream's leak;
+	* - errors on sign-in/sign-out are **not** routed here: the `error` and
+	*   `completed` callbacks of `onIdTokenChanged` are deprecated in Firebase and
+	*   documented as never firing. Catch those on the promise returned by
+	*   `signInWithPopup` / `signOut` itself; `error` only reports a subscription
+	*   that could not be established;
+	* - the latest `errorHandler` is read from a ref, so passing an inline handler
+	*   does not re-subscribe;
+	* - nothing runs while rendering, so server rendering is safe.
+	*
+	* @see https://vueuse.org/firebase/useAuth/
+	*
+	* @example
+	* const auth = getAuth(app)
+	* const { isAuthenticated, user, loading, error } = useAuth(auth)
+	* if (loading) return <div>Loading...</div>
+	* if (!isAuthenticated) return <div>Please log in</div>
+	* return <div>Welcome, {user.displayName}</div>
+	*
+	* @__NO_SIDE_EFFECTS__
+	*/
+	function useAuth(auth, options = {}) {
+		const { errorHandler = (err) => console.error(err) } = options;
+		const [user, setUser] = (0, react.useState)(() => auth.currentUser);
+		const [loading, setLoading] = (0, react.useState)(true);
+		const [error, setError] = (0, react.useState)(null);
+		const errorHandlerRef = (0, react.useRef)(errorHandler);
+		(0, react.useEffect)(() => {
+			errorHandlerRef.current = errorHandler;
+		}, [errorHandler]);
+		const subscribedAuthRef = (0, react.useRef)(auth);
+		(0, react.useEffect)(() => {
+			if (subscribedAuthRef.current !== auth) {
+				subscribedAuthRef.current = auth;
+				setUser(auth.currentUser);
+				setLoading(true);
+				setError(null);
+			}
+			let unsubscribe;
+			let active = true;
+			try {
+				unsubscribe = auth.onIdTokenChanged((authUser) => {
+					if (!active) return;
+					setUser(authUser);
+					setLoading(false);
+				});
+			} catch (err) {
+				const subscriptionError = err instanceof Error ? err : new Error(String(err));
+				setError(subscriptionError);
+				setLoading(false);
+				errorHandlerRef.current(subscriptionError);
+			}
+			return () => {
+				active = false;
+				unsubscribe === null || unsubscribe === void 0 || unsubscribe();
+			};
+		}, [auth]);
+		return {
+			isAuthenticated: user !== null,
+			user,
+			loading,
+			error
+		};
+	}
+	//#endregion
+	exports.useAuth = useAuth;
+})(this.reause = this.reause || {}, React);

package/dist/useAuth.iife.min.js

@@ -0,0 +1 @@
+(function(e,t){Object.defineProperty(e,Symbol.toStringTag,{value:`Module`});function n(e,n={}){let{errorHandler:r=e=>console.error(e)}=n,[i,a]=(0,t.useState)(()=>e.currentUser),[o,s]=(0,t.useState)(!0),[c,l]=(0,t.useState)(null),u=(0,t.useRef)(r);(0,t.useEffect)(()=>{u.current=r},[r]);let d=(0,t.useRef)(e);return(0,t.useEffect)(()=>{d.current!==e&&(d.current=e,a(e.currentUser),s(!0),l(null));let t,n=!0;try{t=e.onIdTokenChanged(e=>{n&&(a(e),s(!1))})}catch(e){let t=e instanceof Error?e:Error(String(e));l(t),s(!1),u.current(t)}return()=>{n=!1,t==null||t()}},[e]),{isAuthenticated:i!==null,user:i,loading:o,error:c}}e.useAuth=n})(this.reause=this.reause||{},React);

package/dist/useAuth.js

@@ -0,0 +1,95 @@
+import { useEffect, useRef, useState } from "react";
+//#region useAuth/index.tsx
+/**
+* React port of VueUse's `useAuth`.
+*
+* Map from @vueuse/firebase/useAuth
+* (`source/vueuse/packages/firebase/useAuth/`). Reactive
+* [Firebase Auth](https://firebase.google.com/docs/auth) binding — it exposes
+* the current `user` and an `isAuthenticated` flag, so a component can react to
+* sign-in, sign-out and ID-token refresh events.
+*
+* Adjustment for React:
+* - the `Auth` instance stays the first argument (`useAuth(auth)`), but the
+*   return is a plain object `{ isAuthenticated, user, loading, error }` — the
+*   values are read during render instead of being Vue refs (`ComputedRef`
+*   / `Ref`), and the object is returned rather than a destructured tuple;
+* - `loading` and `error` are additions to upstream. Firebase reports the
+*   current auth state **asynchronously**, so a port without `loading` would
+*   render the signed-out UI for one frame before the listener corrects it;
+*   `loading` starts `true` and flips to `false` with the first callback (a
+*   signed-out callback included). `error` stays `null` unless subscribing
+*   itself throws;
+* - `user` is seeded from `auth.currentUser` (upstream's
+*   `ref(auth.currentUser)`), so an already signed-in visitor renders
+*   authenticated on the very first pass, while `loading` is still `true`;
+* - upstream subscribes in `setup()` and **never** unsubscribes; this port
+*   subscribes in an effect keyed on `auth` and returns the listener's
+*   `Unsubscribe` as cleanup, so a new `Auth` instance re-subscribes (and
+*   re-seeds `user`/`loading`/`error`) and unmounting stops the listener — a
+*   deliberate React-idiomatic deviation that fixes upstream's leak;
+* - errors on sign-in/sign-out are **not** routed here: the `error` and
+*   `completed` callbacks of `onIdTokenChanged` are deprecated in Firebase and
+*   documented as never firing. Catch those on the promise returned by
+*   `signInWithPopup` / `signOut` itself; `error` only reports a subscription
+*   that could not be established;
+* - the latest `errorHandler` is read from a ref, so passing an inline handler
+*   does not re-subscribe;
+* - nothing runs while rendering, so server rendering is safe.
+*
+* @see https://vueuse.org/firebase/useAuth/
+*
+* @example
+* const auth = getAuth(app)
+* const { isAuthenticated, user, loading, error } = useAuth(auth)
+* if (loading) return <div>Loading...</div>
+* if (!isAuthenticated) return <div>Please log in</div>
+* return <div>Welcome, {user.displayName}</div>
+*
+* @__NO_SIDE_EFFECTS__
+*/
+function useAuth(auth, options = {}) {
+	const { errorHandler = (err) => console.error(err) } = options;
+	const [user, setUser] = useState(() => auth.currentUser);
+	const [loading, setLoading] = useState(true);
+	const [error, setError] = useState(null);
+	const errorHandlerRef = useRef(errorHandler);
+	useEffect(() => {
+		errorHandlerRef.current = errorHandler;
+	}, [errorHandler]);
+	const subscribedAuthRef = useRef(auth);
+	useEffect(() => {
+		if (subscribedAuthRef.current !== auth) {
+			subscribedAuthRef.current = auth;
+			setUser(auth.currentUser);
+			setLoading(true);
+			setError(null);
+		}
+		let unsubscribe;
+		let active = true;
+		try {
+			unsubscribe = auth.onIdTokenChanged((authUser) => {
+				if (!active) return;
+				setUser(authUser);
+				setLoading(false);
+			});
+		} catch (err) {
+			const subscriptionError = err instanceof Error ? err : new Error(String(err));
+			setError(subscriptionError);
+			setLoading(false);
+			errorHandlerRef.current(subscriptionError);
+		}
+		return () => {
+			active = false;
+			unsubscribe === null || unsubscribe === void 0 || unsubscribe();
+		};
+	}, [auth]);
+	return {
+		isAuthenticated: user !== null,
+		user,
+		loading,
+		error
+	};
+}
+//#endregion
+export { useAuth };

package/dist/useFirestore.d.ts

@@ -0,0 +1,25 @@
+import { DocumentData, DocumentReference, Query } from "firebase/firestore";
+//#region useFirestore/index.d.ts
+export interface UseFirestoreOptions {
+  /**
+   * Custom error handler for Firestore subscription errors.
+   *
+   * @default (error) => console.error(error)
+   */
+  errorHandler?: (err: Error) => void;
+  /**
+   * Automatically unsubscribe when the component unmounts. Pass a number to
+   * delay the unsubscribe by that many milliseconds (upstream's
+   * `useTimeoutFn`-based delayed dispose).
+   *
+   * @default true
+   */
+  autoDispose?: boolean | number;
+}
+export type FirebaseDocRef<T> = Query<T> | DocumentReference<T>;
+type Falsy = false | 0 | '' | null | undefined;
+export declare function useFirestore<T extends DocumentData>(maybeDocRef: DocumentReference<T> | Falsy, initialValue: T, options?: UseFirestoreOptions): T | null;
+export declare function useFirestore<T extends DocumentData>(maybeDocRef: Query<T> | Falsy, initialValue: T[], options?: UseFirestoreOptions): T[];
+export declare function useFirestore<T extends DocumentData>(maybeDocRef: DocumentReference<T> | Falsy, initialValue?: T | undefined | null, options?: UseFirestoreOptions): T | undefined | null;
+export declare function useFirestore<T extends DocumentData>(maybeDocRef: Query<T> | Falsy, initialValue?: T[], options?: UseFirestoreOptions): T[] | undefined;
+//#endregion

package/dist/useFirestore.iife.js

@@ -0,0 +1,120 @@
+(function(exports, _reause_shared, react) {
+	Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+	//#region useFirestore/index.tsx
+	/**
+	* Attach the document `id` as a non-writable property of the snapshot data —
+	* ported verbatim from upstream. `data()` may be `undefined` for a deleted
+	* document.
+	*/
+	function getData(docRef) {
+		const data = docRef.data();
+		if (data) Object.defineProperty(data, "id", {
+			value: docRef.id.toString(),
+			writable: false
+		});
+		return data;
+	}
+	/**
+	* Slash-parity check, ported verbatim from upstream: a `DocumentReference`
+	* path has an odd number of segments (`users/ada`), a `Query` path an even
+	* number (`users` or `users/ada/posts`).
+	*/
+	function isDocumentReference(docRef) {
+		var _docRef$path;
+		return (((_docRef$path = docRef.path) === null || _docRef$path === void 0 ? void 0 : _docRef$path.match(/\//g)) || []).length % 2 !== 0;
+	}
+	/**
+	* React port of VueUse's `useFirestore`.
+	*
+	* Map from @vueuse/firebase/useFirestore
+	* (`source/vueuse/packages/firebase/useFirestore/`). Reactive
+	* [Firestore](https://firebase.google.com/docs/firestore) binding — it keeps
+	* local state in sync with a document reference or a query, so a component
+	* always renders the freshest remote data.
+	*
+	* Adjustment for React:
+	* - `maybeDocRef` is a plain value (upstream accepts `MaybeRef`): read-only
+	*   value-source parameters take plain `T`. Pass a new reference/query
+	*   identity to re-subscribe — **keep it stable across renders** (memoize
+	*   `doc`/`collection`/`query` results): a fresh identity on every render
+	*   re-subscribes on every render;
+	* - the return is the plain state VALUE (not a tuple, not an object) —
+	*   upstream exposes no setter (0 writable values), so the shape mirrors the
+	*   read side of upstream's `Ref<T | null>` / `Ref<T[]>`; a document resolves
+	*   to `T | null` (a deleted document becomes `null`), a query to `T[]`;
+	* - the subscription lives in an effect keyed on `maybeDocRef`, so a new
+	*   ref/query identity re-subscribes and closes the previous `onSnapshot`
+	*   (upstream's immediate watch); a falsy docRef resets `data` to
+	*   `initialValue`;
+	* - `firebase/firestore` is loaded through a guarded **dynamic** import, so
+	*   this module never throws at import time when `firebase` is missing — a
+	*   missing module or a failed `onSnapshot` call surfaces through
+	*   `errorHandler` instead, and `data` stays at `initialValue`;
+	* - the latest `errorHandler` is read from a ref, so passing an inline handler
+	*   does not re-subscribe;
+	* - nothing runs while rendering, so server rendering is safe.
+	*
+	* @see https://vueuse.org/firebase/useFirestore/
+	*
+	* @example
+	* const todos = useFirestore(collection(db, 'todos'))
+	* const user = useFirestore(doc(db, 'users', 'my-user-id'))
+	*
+	* @__NO_SIDE_EFFECTS__
+	*/
+	function useFirestore(maybeDocRef, initialValue = void 0, options = {}) {
+		const { errorHandler = (err) => console.error(err), autoDispose = true } = options;
+		const [data, setData] = (0, react.useState)(initialValue);
+		const initialValueRef = (0, react.useRef)(initialValue);
+		const autoDisposeRef = (0, react.useRef)(autoDispose);
+		const errorHandlerRef = (0, react.useRef)(errorHandler);
+		(0, react.useEffect)(() => {
+			errorHandlerRef.current = errorHandler;
+		}, [errorHandler]);
+		const closeRef = (0, react.useRef)(() => {});
+		(0, react.useEffect)(() => {
+			closeRef.current();
+			closeRef.current = () => {};
+			if (!maybeDocRef) {
+				setData(initialValueRef.current);
+				return;
+			}
+			let active = true;
+			let close;
+			import("firebase/firestore").then(({ onSnapshot }) => {
+				if (!active) return;
+				try {
+					var _close;
+					if (isDocumentReference(maybeDocRef)) close = onSnapshot(maybeDocRef, (snapshot) => {
+						if (!active) return;
+						setData(getData(snapshot) || null);
+					}, (err) => errorHandlerRef.current(err));
+					else close = onSnapshot(maybeDocRef, (snapshot) => {
+						if (!active) return;
+						setData(snapshot.docs.map(getData).filter(_reause_shared.isDef));
+					}, (err) => errorHandlerRef.current(err));
+					closeRef.current = (_close = close) !== null && _close !== void 0 ? _close : (() => {});
+				} catch (err) {
+					errorHandlerRef.current(err instanceof Error ? err : new Error(String(err)));
+				}
+			}).catch((err) => {
+				if (!active) return;
+				errorHandlerRef.current(err instanceof Error ? err : new Error(String(err)));
+			});
+			return () => {
+				active = false;
+			};
+		}, [maybeDocRef]);
+		(0, react.useEffect)(() => {
+			return () => {
+				if (autoDisposeRef.current === true) closeRef.current();
+				else if (typeof autoDisposeRef.current === "number") setTimeout(() => {
+					closeRef.current();
+				}, autoDisposeRef.current);
+			};
+		}, []);
+		return data;
+	}
+	//#endregion
+	exports.useFirestore = useFirestore;
+})(this.reause = this.reause || {}, reause, React);

package/dist/useFirestore.iife.min.js

@@ -0,0 +1 @@
+(function(e,t,n){Object.defineProperty(e,Symbol.toStringTag,{value:`Module`});function r(e){let t=e.data();return t&&Object.defineProperty(t,"id",{value:e.id.toString(),writable:!1}),t}function i(e){var t;return(((t=e.path)==null?void 0:t.match(/\//g))||[]).length%2!=0}function a(e,a=void 0,o={}){let{errorHandler:s=e=>console.error(e),autoDispose:c=!0}=o,[l,u]=(0,n.useState)(a),d=(0,n.useRef)(a),f=(0,n.useRef)(c),p=(0,n.useRef)(s);(0,n.useEffect)(()=>{p.current=s},[s]);let m=(0,n.useRef)(()=>{});return(0,n.useEffect)(()=>{if(m.current(),m.current=()=>{},!e){u(d.current);return}let n=!0,a;return import(`firebase/firestore`).then(({onSnapshot:o})=>{if(n)try{var s;a=i(e)?o(e,e=>{n&&u(r(e)||null)},e=>p.current(e)):o(e,e=>{n&&u(e.docs.map(r).filter(t.isDef))},e=>p.current(e)),m.current=(s=a)==null?(()=>{}):s}catch(e){p.current(e instanceof Error?e:Error(String(e)))}}).catch(e=>{n&&p.current(e instanceof Error?e:Error(String(e)))}),()=>{n=!1}},[e]),(0,n.useEffect)(()=>()=>{f.current===!0?m.current():typeof f.current==`number`&&setTimeout(()=>{m.current()},f.current)},[]),l}e.useFirestore=a})(this.reause=this.reause||{},reause,React);

package/dist/useFirestore.js

@@ -0,0 +1,119 @@
+import { useEffect, useRef, useState } from "react";
+import { isDef } from "@reause/shared";
+//#region useFirestore/index.tsx
+/**
+* Attach the document `id` as a non-writable property of the snapshot data —
+* ported verbatim from upstream. `data()` may be `undefined` for a deleted
+* document.
+*/
+function getData(docRef) {
+	const data = docRef.data();
+	if (data) Object.defineProperty(data, "id", {
+		value: docRef.id.toString(),
+		writable: false
+	});
+	return data;
+}
+/**
+* Slash-parity check, ported verbatim from upstream: a `DocumentReference`
+* path has an odd number of segments (`users/ada`), a `Query` path an even
+* number (`users` or `users/ada/posts`).
+*/
+function isDocumentReference(docRef) {
+	var _docRef$path;
+	return (((_docRef$path = docRef.path) === null || _docRef$path === void 0 ? void 0 : _docRef$path.match(/\//g)) || []).length % 2 !== 0;
+}
+/**
+* React port of VueUse's `useFirestore`.
+*
+* Map from @vueuse/firebase/useFirestore
+* (`source/vueuse/packages/firebase/useFirestore/`). Reactive
+* [Firestore](https://firebase.google.com/docs/firestore) binding — it keeps
+* local state in sync with a document reference or a query, so a component
+* always renders the freshest remote data.
+*
+* Adjustment for React:
+* - `maybeDocRef` is a plain value (upstream accepts `MaybeRef`): read-only
+*   value-source parameters take plain `T`. Pass a new reference/query
+*   identity to re-subscribe — **keep it stable across renders** (memoize
+*   `doc`/`collection`/`query` results): a fresh identity on every render
+*   re-subscribes on every render;
+* - the return is the plain state VALUE (not a tuple, not an object) —
+*   upstream exposes no setter (0 writable values), so the shape mirrors the
+*   read side of upstream's `Ref<T | null>` / `Ref<T[]>`; a document resolves
+*   to `T | null` (a deleted document becomes `null`), a query to `T[]`;
+* - the subscription lives in an effect keyed on `maybeDocRef`, so a new
+*   ref/query identity re-subscribes and closes the previous `onSnapshot`
+*   (upstream's immediate watch); a falsy docRef resets `data` to
+*   `initialValue`;
+* - `firebase/firestore` is loaded through a guarded **dynamic** import, so
+*   this module never throws at import time when `firebase` is missing — a
+*   missing module or a failed `onSnapshot` call surfaces through
+*   `errorHandler` instead, and `data` stays at `initialValue`;
+* - the latest `errorHandler` is read from a ref, so passing an inline handler
+*   does not re-subscribe;
+* - nothing runs while rendering, so server rendering is safe.
+*
+* @see https://vueuse.org/firebase/useFirestore/
+*
+* @example
+* const todos = useFirestore(collection(db, 'todos'))
+* const user = useFirestore(doc(db, 'users', 'my-user-id'))
+*
+* @__NO_SIDE_EFFECTS__
+*/
+function useFirestore(maybeDocRef, initialValue = void 0, options = {}) {
+	const { errorHandler = (err) => console.error(err), autoDispose = true } = options;
+	const [data, setData] = useState(initialValue);
+	const initialValueRef = useRef(initialValue);
+	const autoDisposeRef = useRef(autoDispose);
+	const errorHandlerRef = useRef(errorHandler);
+	useEffect(() => {
+		errorHandlerRef.current = errorHandler;
+	}, [errorHandler]);
+	const closeRef = useRef(() => {});
+	useEffect(() => {
+		closeRef.current();
+		closeRef.current = () => {};
+		if (!maybeDocRef) {
+			setData(initialValueRef.current);
+			return;
+		}
+		let active = true;
+		let close;
+		import("firebase/firestore").then(({ onSnapshot }) => {
+			if (!active) return;
+			try {
+				var _close;
+				if (isDocumentReference(maybeDocRef)) close = onSnapshot(maybeDocRef, (snapshot) => {
+					if (!active) return;
+					setData(getData(snapshot) || null);
+				}, (err) => errorHandlerRef.current(err));
+				else close = onSnapshot(maybeDocRef, (snapshot) => {
+					if (!active) return;
+					setData(snapshot.docs.map(getData).filter(isDef));
+				}, (err) => errorHandlerRef.current(err));
+				closeRef.current = (_close = close) !== null && _close !== void 0 ? _close : (() => {});
+			} catch (err) {
+				errorHandlerRef.current(err instanceof Error ? err : new Error(String(err)));
+			}
+		}).catch((err) => {
+			if (!active) return;
+			errorHandlerRef.current(err instanceof Error ? err : new Error(String(err)));
+		});
+		return () => {
+			active = false;
+		};
+	}, [maybeDocRef]);
+	useEffect(() => {
+		return () => {
+			if (autoDisposeRef.current === true) closeRef.current();
+			else if (typeof autoDisposeRef.current === "number") setTimeout(() => {
+				closeRef.current();
+			}, autoDisposeRef.current);
+		};
+	}, []);
+	return data;
+}
+//#endregion
+export { useFirestore };

package/dist/useRTDB.d.ts

@@ -0,0 +1,59 @@
+import { DatabaseReference } from "firebase/database";
+//#region useRTDB/index.d.ts
+export interface UseRTDBOptions {
+  /**
+   * Custom error handler for database errors.
+   *
+   * @default (error) => console.error(error)
+   */
+  errorHandler?: (err: Error) => void;
+  /**
+   * Automatically unsubscribe from the database reference when the component
+   * unmounts.
+   *
+   * @default true
+   */
+  autoDispose?: boolean;
+}
+/**
+ * Result tuple of `useRTDB`, mirroring upstream's writable Vue ref:
+ * `[data, setData]`.
+ */
+export type UseRTDBReturn<T> = [data: T | undefined, setData: (value: T | undefined) => void];
+/**
+ * React port of VueUse's `useRTDB`.
+ *
+ * Map from @vueuse/firebase `useRTDB`
+ *
+ * Reactive [Firebase Realtime Database](https://firebase.google.com/docs/database)
+ * binding — keeps local state in sync with a database reference. The listener
+ * is registered with `onValue` in a mount effect and feeds `data` with
+ * `snapshot.val()` on every database change.
+ *
+ * Adjustment for React:
+ * - upstream returns a writable `Ref<T | undefined>`, so this port returns the
+ *   `[data, setData]` tuple; `data` starts `undefined` and holds the latest
+ *   snapshot value;
+ * - `setData` writes **local state only** — it does not write to the Realtime
+ *   Database (upstream's ref is equally local). Use the `firebase/database`
+ *   write APIs (`set` / `update` / `push`) to persist;
+ * - the subscription lives in a `useEffect` keyed on `docRef` and `autoDispose`,
+ *   so a new `docRef` identity re-subscribes and unsubscribes the previous
+ *   listener (upstream subscribes once per `setup()` — a deliberate
+ *   React-idiomatic deviation);
+ * - cleanup calls the `onValue` unsubscribe only when `autoDispose` is `true`
+ *   (upstream parity). `autoDispose: false` means the subscription outlives the
+ *   component: the caller gets no `off` handle and must live with the leak —
+ *   discouraged, kept only for upstream parity;
+ * - the latest `errorHandler` is read from a ref, so passing an inline handler
+ *   does not re-subscribe.
+ *
+ * @see https://vueuse.org/useRTDB
+ *
+ * @example
+ * const [todos, setTodos] = useRTDB<Record<string, Todo>>(ref(getDatabase(app), 'todos'))
+ *
+ * @__NO_SIDE_EFFECTS__
+ */
+export declare function useRTDB<T = any>(docRef: DatabaseReference, options?: UseRTDBOptions): UseRTDBReturn<T>;
+//#endregion

package/dist/useRTDB.iife.js

@@ -0,0 +1,56 @@
+(function(exports, firebase_database, react) {
+	Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+	//#region useRTDB/index.tsx
+	/**
+	* React port of VueUse's `useRTDB`.
+	*
+	* Map from @vueuse/firebase `useRTDB`
+	*
+	* Reactive [Firebase Realtime Database](https://firebase.google.com/docs/database)
+	* binding — keeps local state in sync with a database reference. The listener
+	* is registered with `onValue` in a mount effect and feeds `data` with
+	* `snapshot.val()` on every database change.
+	*
+	* Adjustment for React:
+	* - upstream returns a writable `Ref<T | undefined>`, so this port returns the
+	*   `[data, setData]` tuple; `data` starts `undefined` and holds the latest
+	*   snapshot value;
+	* - `setData` writes **local state only** — it does not write to the Realtime
+	*   Database (upstream's ref is equally local). Use the `firebase/database`
+	*   write APIs (`set` / `update` / `push`) to persist;
+	* - the subscription lives in a `useEffect` keyed on `docRef` and `autoDispose`,
+	*   so a new `docRef` identity re-subscribes and unsubscribes the previous
+	*   listener (upstream subscribes once per `setup()` — a deliberate
+	*   React-idiomatic deviation);
+	* - cleanup calls the `onValue` unsubscribe only when `autoDispose` is `true`
+	*   (upstream parity). `autoDispose: false` means the subscription outlives the
+	*   component: the caller gets no `off` handle and must live with the leak —
+	*   discouraged, kept only for upstream parity;
+	* - the latest `errorHandler` is read from a ref, so passing an inline handler
+	*   does not re-subscribe.
+	*
+	* @see https://vueuse.org/useRTDB
+	*
+	* @example
+	* const [todos, setTodos] = useRTDB<Record<string, Todo>>(ref(getDatabase(app), 'todos'))
+	*
+	* @__NO_SIDE_EFFECTS__
+	*/
+	function useRTDB(docRef, options = {}) {
+		const { errorHandler = (err) => console.error(err), autoDispose = true } = options;
+		const [data, setData] = (0, react.useState)(void 0);
+		const errorHandlerRef = (0, react.useRef)(errorHandler);
+		(0, react.useEffect)(() => {
+			errorHandlerRef.current = errorHandler;
+		}, [errorHandler]);
+		(0, react.useEffect)(() => {
+			const off = (0, firebase_database.onValue)(docRef, (snapshot) => setData(snapshot.val()), (err) => errorHandlerRef.current(err));
+			return () => {
+				if (autoDispose) off();
+			};
+		}, [docRef, autoDispose]);
+		return [data, setData];
+	}
+	//#endregion
+	exports.useRTDB = useRTDB;
+})(this.reause = this.reause || {}, firebase, React);

package/dist/useRTDB.iife.min.js

@@ -0,0 +1 @@
+(function(e,t,n){Object.defineProperty(e,Symbol.toStringTag,{value:`Module`});function r(e,r={}){let{errorHandler:i=e=>console.error(e),autoDispose:a=!0}=r,[o,s]=(0,n.useState)(void 0),c=(0,n.useRef)(i);return(0,n.useEffect)(()=>{c.current=i},[i]),(0,n.useEffect)(()=>{let n=(0,t.onValue)(e,e=>s(e.val()),e=>c.current(e));return()=>{a&&n()}},[e,a]),[o,s]}e.useRTDB=r})(this.reause=this.reause||{},firebase,React);

package/dist/useRTDB.js

@@ -0,0 +1,55 @@
+import { useEffect, useRef, useState } from "react";
+import { onValue } from "firebase/database";
+//#region useRTDB/index.tsx
+/**
+* React port of VueUse's `useRTDB`.
+*
+* Map from @vueuse/firebase `useRTDB`
+*
+* Reactive [Firebase Realtime Database](https://firebase.google.com/docs/database)
+* binding — keeps local state in sync with a database reference. The listener
+* is registered with `onValue` in a mount effect and feeds `data` with
+* `snapshot.val()` on every database change.
+*
+* Adjustment for React:
+* - upstream returns a writable `Ref<T | undefined>`, so this port returns the
+*   `[data, setData]` tuple; `data` starts `undefined` and holds the latest
+*   snapshot value;
+* - `setData` writes **local state only** — it does not write to the Realtime
+*   Database (upstream's ref is equally local). Use the `firebase/database`
+*   write APIs (`set` / `update` / `push`) to persist;
+* - the subscription lives in a `useEffect` keyed on `docRef` and `autoDispose`,
+*   so a new `docRef` identity re-subscribes and unsubscribes the previous
+*   listener (upstream subscribes once per `setup()` — a deliberate
+*   React-idiomatic deviation);
+* - cleanup calls the `onValue` unsubscribe only when `autoDispose` is `true`
+*   (upstream parity). `autoDispose: false` means the subscription outlives the
+*   component: the caller gets no `off` handle and must live with the leak —
+*   discouraged, kept only for upstream parity;
+* - the latest `errorHandler` is read from a ref, so passing an inline handler
+*   does not re-subscribe.
+*
+* @see https://vueuse.org/useRTDB
+*
+* @example
+* const [todos, setTodos] = useRTDB<Record<string, Todo>>(ref(getDatabase(app), 'todos'))
+*
+* @__NO_SIDE_EFFECTS__
+*/
+function useRTDB(docRef, options = {}) {
+	const { errorHandler = (err) => console.error(err), autoDispose = true } = options;
+	const [data, setData] = useState(void 0);
+	const errorHandlerRef = useRef(errorHandler);
+	useEffect(() => {
+		errorHandlerRef.current = errorHandler;
+	}, [errorHandler]);
+	useEffect(() => {
+		const off = onValue(docRef, (snapshot) => setData(snapshot.val()), (err) => errorHandlerRef.current(err));
+		return () => {
+			if (autoDispose) off();
+		};
+	}, [docRef, autoDispose]);
+	return [data, setData];
+}
+//#endregion
+export { useRTDB };

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@reause/firebase",
+  "type": "module",
+  "version": "0.1.2",
+  "description": "Realtime bindings for Firebase — React port of @vueuse/firebase",
+  "license": "MIT",
+  "sideEffects": false,
+  "exports": {
+    ".": "./dist/index.js",
+    "./*": "./dist/*",
+    "./useAuth": "./dist/useAuth.js",
+    "./useFirestore": "./dist/useFirestore.js",
+    "./useRTDB": "./dist/useRTDB.js",
+    "./package.json": "./package.json"
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "unpkg": "./dist/index.iife.min.js",
+  "jsdelivr": "./dist/index.iife.min.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "peerDependencies": {
+    "firebase": ">=9.0.0",
+    "react": ">=18"
+  },
+  "scripts": {
+    "build": "tsdown"
+  }
+}