feat: add storage module

src/index.ts

@@ -1,2 +1,4 @@
 export * from "./common";
 export * from "./firestore";
+export * from "./storage";
+

src/storage/index.ts

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

src/storage/internal.ts

@@ -0,0 +1,16 @@
+import { StorageReference } from "@firebase/storage";
+import { useStableValue } from "../util/useStableValue";
+
+/**
+ * @internal
+ */
+function isStorageRefEqual(a: StorageReference | undefined, b: StorageReference | undefined): boolean {
+    return a?.fullPath === b?.fullPath;
+}
+
+/**
+ * @internal
+ */
+export function useStableStorageRef(query: StorageReference | undefined): StorageReference | undefined {
+    return useStableValue(query, isStorageRefEqual);
+}

src/storage/useDownloadURL.ts

@@ -0,0 +1,44 @@
+import { getDownloadURL, StorageError, StorageReference } from "firebase/storage";
+import { useEffect, useMemo } from "react";
+import { ValueHookResult } from "../common";
+import { useIsMounted } from "../util/useIsMounted";
+import { useLoadingValue } from "../util/useLoadingValue";
+import { useStableStorageRef } from "./internal";
+
+export type UseDownloadURLResult = ValueHookResult<string, StorageError>;
+
+export function useDownloadURL(reference: StorageReference): UseDownloadURLResult {
+    const isMounted = useIsMounted();
+    const { value, setValue, loading, setLoading, error, setError } = useLoadingValue<string, StorageError>();
+
+    const stableStorageRef = useStableStorageRef(reference ?? undefined);
+
+    useEffect(() => {
+        (async () => {
+            if (stableStorageRef === undefined) {
+                setValue();
+            } else {
+                setLoading();
+
+                try {
+                    const url = await getDownloadURL(stableStorageRef);
+
+                    if (!isMounted.current) {
+                        return;
+                    }
+
+                    setValue(url);
+                } catch (e) {
+                    if (!isMounted.current) {
+                        return;
+                    }
+
+                    // We assume this is always a StorageError
+                    setError(e as unknown as StorageError);
+                }
+            }
+        })();
+    }, [stableStorageRef]);
+
+    return useMemo(() => [value, loading, error], [value, loading, error]);
+}