@umituz/web-firebase 3.2.3 → 3.3.0

package/src/presentation/hooks/useStorage.ts

@@ -1,141 +0,0 @@
-/**
- * Storage Hook
- * @description React hook for file storage operations
- * Migrated from: /Users/umituz/Desktop/github/umituz/apps/web/app-growth-factory/src/domains/firebase/hooks/useStorage.ts
- */
-
-import { useState, useCallback } from 'react'
-import type { IFileRepository } from '../../domain/interfaces/file.repository.interface'
-import type { UploadProgress, UploadResult } from '../../domain/entities/file.entity'
-
-export interface UseStorageOptions {
-  fileRepository: IFileRepository
-  userId: string
-}
-
-export function useStorage({ fileRepository, userId }: UseStorageOptions) {
-  const [uploading, setUploading] = useState(false)
-  const [progress, setProgress] = useState(0)
-  const [error, setError] = useState<Error | null>(null)
-
-  const uploadFile = useCallback(
-    async (path: string, file: File): Promise<UploadResult> => {
-      setUploading(true)
-      setProgress(0)
-      setError(null)
-
-      try {
-        const result = await fileRepository.uploadFile(userId, path, file, {
-          onProgress: (progress: UploadProgress) => {
-            setProgress(progress.progress)
-          },
-        })
-
-        setProgress(100)
-        return result
-      } catch (err) {
-        setError(err as Error)
-        throw err
-      } finally {
-        setUploading(false)
-      }
-    },
-    [fileRepository, userId]
-  )
-
-  const uploadImage = useCallback(
-    async (file: File): Promise<UploadResult> => {
-      return uploadFile('images', file)
-    },
-    [uploadFile]
-  )
-
-  const uploadVideo = useCallback(
-    async (file: File): Promise<UploadResult> => {
-      return uploadFile('videos', file)
-    },
-    [uploadFile]
-  )
-
-  const uploadDocument = useCallback(
-    async (file: File): Promise<UploadResult> => {
-      return uploadFile('documents', file)
-    },
-    [uploadFile]
-  )
-
-  const uploadProfilePicture = useCallback(
-    async (file: File): Promise<UploadResult> => {
-      setUploading(true)
-      setError(null)
-
-      try {
-        const result = await fileRepository.uploadProfilePicture(userId, file)
-        return result
-      } catch (err) {
-        setError(err as Error)
-        throw err
-      } finally {
-        setUploading(false)
-      }
-    },
-    [fileRepository, userId]
-  )
-
-  const deleteFile = useCallback(
-    async (path: string): Promise<void> => {
-      setUploading(true)
-      setError(null)
-
-      try {
-        await fileRepository.deleteFile(path)
-      } catch (err) {
-        setError(err as Error)
-        throw err
-      } finally {
-        setUploading(false)
-      }
-    },
-    [fileRepository]
-  )
-
-  const listUserImages = useCallback(
-    async (): Promise<string[]> => {
-      setError(null)
-      try {
-        return await fileRepository.listUserImages(userId)
-      } catch (err) {
-        setError(err as Error)
-        throw err
-      }
-    },
-    [fileRepository, userId]
-  )
-
-  const listUserVideos = useCallback(
-    async (): Promise<string[]> => {
-      setError(null)
-      try {
-        return await fileRepository.listUserVideos(userId)
-      } catch (err) {
-        setError(err as Error)
-        throw err
-      }
-    },
-    [fileRepository, userId]
-  )
-
-  return {
-    uploadFile,
-    uploadImage,
-    uploadVideo,
-    uploadDocument,
-    uploadProfilePicture,
-    deleteFile,
-    listUserImages,
-    listUserVideos,
-    uploading,
-    progress,
-    error,
-  }
-}

package/src/presentation/index.ts

@@ -1,10 +0,0 @@
-/**
- * Presentation Layer
- * Subpath: @umituz/web-firebase/presentation
- */
-
-export * from './hooks/useAuth';
-export * from './hooks/useFirebaseAuth';
-export * from './hooks/useFirestore';
-export * from './hooks/useStorage';
-export * from './providers/FirebaseProvider';

package/src/presentation/providers/FirebaseProvider.tsx

@@ -1,90 +0,0 @@
-/**
- * FirebaseProvider
- * @description React Context Provider for Firebase with auth state tracking
- */
-
-import { createContext, useContext, useState, useEffect, type ReactNode } from 'react'
-import type { User } from 'firebase/auth'
-import type { FirebaseInstances } from '../../infrastructure/firebase/client'
-import { getFirebaseInstances } from '../../infrastructure/firebase/client'
-import type { AuthUser } from '../../domains/auth/entities'
-import { authService } from '../../domains/auth/services'
-
-export interface FirebaseContextValue {
-  instances: FirebaseInstances
-  isInitialized: boolean
-  user: User | null
-  authUser: AuthUser | null
-  loading: boolean
-  error: Error | null
-}
-
-const FirebaseContext = createContext<FirebaseContextValue | null>(null)
-
-export interface FirebaseProviderProps {
-  children: ReactNode
-  config?: {
-    apiKey: string
-    authDomain: string
-    projectId: string
-    storageBucket: string
-    messagingSenderId: string
-    appId: string
-  }
-}
-
-export function FirebaseProvider({ children, config }: FirebaseProviderProps) {
-  const [instances, setInstances] = useState<FirebaseInstances | null>(null)
-  const [user, setUser] = useState<User | null>(null)
-  const [authUser, setAuthUser] = useState<AuthUser | null>(null)
-  const [loading, setLoading] = useState(true)
-  const [error, setError] = useState<Error | null>(null)
-
-  useEffect(() => {
-    try {
-      // Initialize Firebase (singleton - won't re-initialize)
-      const firebaseInstances = getFirebaseInstances()
-      setInstances(firebaseInstances)
-
-      // Set up auth state listener
-      const unsubscribe = authService.onAuthStateChanged(
-        (newAuthUser) => {
-          setAuthUser(newAuthUser)
-          setUser(newAuthUser ? (firebaseInstances.auth.currentUser || null) : null)
-          setLoading(false)
-          setError(null)
-        },
-        (err) => {
-          setError(err)
-          setLoading(false)
-        }
-      )
-
-      return () => {
-        if (unsubscribe) unsubscribe()
-      }
-    } catch (err) {
-      setError(err as Error)
-      setLoading(false)
-    }
-  }, [config])
-
-  const value: FirebaseContextValue = {
-    instances: instances!,
-    isInitialized: !!instances,
-    user,
-    authUser,
-    loading,
-    error,
-  }
-
-  return <FirebaseContext.Provider value={value}>{children}</FirebaseContext.Provider>
-}
-
-export function useFirebaseContext(): FirebaseContextValue {
-  const context = useContext(FirebaseContext)
-  if (!context) {
-    throw new Error('useFirebaseContext must be used within FirebaseProvider')
-  }
-  return context
-}