@moontra/moonui-pro 2.17.5 → 2.18.0

package/src/components/github-stars/hooks.ts

@@ -0,0 +1,304 @@
+import { useState, useEffect, useCallback, useRef } from "react"
+import {
+  GitHubRepository,
+  GitHubStats,
+  RateLimitInfo,
+  StarHistory,
+  Milestone,
+} from "./types"
+import {
+  fetchUserRepositories,
+  fetchRepository,
+  fetchContributorsCount,
+  fetchStarHistory,
+  calculateStats,
+  getRateLimitInfo,
+  clearCache,
+} from "./github-api"
+
+interface UseGitHubDataOptions {
+  username?: string
+  repository?: string
+  repositories?: string[]
+  token?: string
+  autoRefresh?: boolean
+  refreshInterval?: number
+  sortBy?: string
+  maxItems?: number
+  onError?: (error: Error) => void
+  onDataUpdate?: (stats: GitHubStats) => void
+  onMilestoneReached?: (milestone: Milestone) => void
+  milestones?: number[]
+}
+
+export function useGitHubData({
+  username,
+  repository,
+  repositories,
+  token,
+  autoRefresh = false,
+  refreshInterval = 300000,
+  sortBy = "stars",
+  maxItems,
+  onError,
+  onDataUpdate,
+  onMilestoneReached,
+  milestones = [10, 50, 100, 500, 1000, 5000, 10000],
+}: UseGitHubDataOptions) {
+  const [repos, setRepos] = useState<GitHubRepository[]>([])
+  const [stats, setStats] = useState<GitHubStats | null>(null)
+  const [loading, setLoading] = useState(true)
+  const [error, setError] = useState<string | null>(null)
+  const [rateLimitInfo, setRateLimitInfo] = useState<RateLimitInfo | null>(null)
+  const [lastUpdated, setLastUpdated] = useState<Date | null>(null)
+  
+  const refreshTimeoutRef = useRef<NodeJS.Timeout>()
+  const previousStarsRef = useRef<Map<string, number>>(new Map())
+
+  const checkMilestones = useCallback((repos: GitHubRepository[]) => {
+    if (!onMilestoneReached) return
+
+    repos.forEach(repo => {
+      const previousStars = previousStarsRef.current.get(repo.full_name) || 0
+      const currentStars = repo.stargazers_count
+
+      milestones.forEach(milestone => {
+        if (previousStars < milestone && currentStars >= milestone) {
+          onMilestoneReached({
+            count: milestone,
+            reached: true,
+            date: new Date().toISOString(),
+            celebration: true,
+          })
+        }
+      })
+
+      previousStarsRef.current.set(repo.full_name, currentStars)
+    })
+  }, [milestones, onMilestoneReached])
+
+  const fetchData = useCallback(async () => {
+    try {
+      setLoading(true)
+      setError(null)
+
+      // Check rate limit first
+      try {
+        const rateLimit = await getRateLimitInfo(token)
+        setRateLimitInfo(rateLimit)
+
+        if (rateLimit.remaining < 10) {
+          console.warn(`Low GitHub API rate limit: ${rateLimit.remaining} requests remaining`)
+        }
+      } catch (error) {
+        console.error("Failed to fetch rate limit:", error)
+      }
+
+      let fetchedRepos: GitHubRepository[] = []
+
+      // Single repository mode
+      if (repository && username) {
+        const repo = await fetchRepository(username, repository, token)
+        fetchedRepos = [repo]
+      }
+      // Multiple specific repositories
+      else if (repositories && repositories.length > 0 && username) {
+        const repoPromises = repositories.map(repoName =>
+          fetchRepository(username, repoName, token)
+        )
+        fetchedRepos = await Promise.all(repoPromises)
+      }
+      // All user repositories
+      else if (username) {
+        fetchedRepos = await fetchUserRepositories(username, token, {
+          sort: sortBy,
+          per_page: 100,
+        })
+      }
+
+      // Sort repositories
+      fetchedRepos.sort((a, b) => {
+        switch (sortBy) {
+          case "stars":
+            return b.stargazers_count - a.stargazers_count
+          case "forks":
+            return b.forks_count - a.forks_count
+          case "updated":
+            return new Date(b.updated_at).getTime() - new Date(a.updated_at).getTime()
+          case "created":
+            return new Date(b.created_at).getTime() - new Date(a.created_at).getTime()
+          case "name":
+            return a.name.localeCompare(b.name)
+          case "issues":
+            return b.open_issues_count - a.open_issues_count
+          default:
+            return 0
+        }
+      })
+
+      // Limit results
+      if (maxItems && maxItems > 0) {
+        fetchedRepos = fetchedRepos.slice(0, maxItems)
+      }
+
+      // Fetch additional data for detailed view
+      const enhancedRepos = await Promise.all(
+        fetchedRepos.map(async repo => {
+          try {
+            const contributorsCount = await fetchContributorsCount(
+              repo.owner.login,
+              repo.name,
+              token
+            )
+            return { ...repo, contributors_count: contributorsCount }
+          } catch (error) {
+            console.error(`Failed to fetch contributors for ${repo.full_name}:`, error)
+            return repo
+          }
+        })
+      )
+
+      setRepos(enhancedRepos)
+      
+      // Calculate statistics
+      const calculatedStats = calculateStats(enhancedRepos)
+      setStats(calculatedStats)
+      
+      // Check milestones
+      checkMilestones(enhancedRepos)
+      
+      // Notify data update
+      if (onDataUpdate) {
+        onDataUpdate(calculatedStats)
+      }
+      
+      setLastUpdated(new Date())
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : "Failed to fetch data"
+      setError(errorMessage)
+      if (onError) {
+        onError(err instanceof Error ? err : new Error(errorMessage))
+      }
+    } finally {
+      setLoading(false)
+    }
+  }, [
+    username,
+    repository,
+    repositories,
+    token,
+    sortBy,
+    maxItems,
+    checkMilestones,
+    onDataUpdate,
+    onError,
+  ])
+
+  // Initial fetch
+  useEffect(() => {
+    fetchData()
+  }, [fetchData])
+
+  // Auto-refresh
+  useEffect(() => {
+    if (!autoRefresh) return
+
+    const scheduleRefresh = () => {
+      refreshTimeoutRef.current = setTimeout(() => {
+        fetchData()
+        scheduleRefresh()
+      }, refreshInterval)
+    }
+
+    scheduleRefresh()
+
+    return () => {
+      if (refreshTimeoutRef.current) {
+        clearTimeout(refreshTimeoutRef.current)
+      }
+    }
+  }, [autoRefresh, refreshInterval, fetchData])
+
+  const refresh = useCallback(() => {
+    clearCache()
+    return fetchData()
+  }, [fetchData])
+
+  return {
+    repos,
+    stats,
+    loading,
+    error,
+    rateLimitInfo,
+    lastUpdated,
+    refresh,
+  }
+}
+
+// Hook for star history
+export function useStarHistory(
+  owner: string,
+  repo: string,
+  token?: string
+) {
+  const [history, setHistory] = useState<StarHistory[]>([])
+  const [loading, setLoading] = useState(true)
+  const [error, setError] = useState<string | null>(null)
+
+  useEffect(() => {
+    const fetchHistory = async () => {
+      try {
+        setLoading(true)
+        setError(null)
+        const data = await fetchStarHistory(owner, repo, token)
+        setHistory(data)
+      } catch (err) {
+        setError(err instanceof Error ? err.message : "Failed to fetch star history")
+      } finally {
+        setLoading(false)
+      }
+    }
+
+    if (owner && repo) {
+      fetchHistory()
+    }
+  }, [owner, repo, token])
+
+  return { history, loading, error }
+}
+
+// Hook for notifications
+export function useGitHubNotifications(enabled: boolean = true) {
+  const [permission, setPermission] = useState<NotificationPermission>("default")
+
+  useEffect(() => {
+    if (!enabled || typeof window === "undefined" || !("Notification" in window)) {
+      return
+    }
+
+    setPermission(Notification.permission)
+
+    if (Notification.permission === "default") {
+      Notification.requestPermission().then(setPermission)
+    }
+  }, [enabled])
+
+  const notify = useCallback(
+    (title: string, options?: NotificationOptions) => {
+      if (!enabled || permission !== "granted") return
+
+      try {
+        new Notification(title, {
+          icon: "/icon-192x192.png",
+          badge: "/icon-192x192.png",
+          ...options,
+        })
+      } catch (error) {
+        console.error("Failed to show notification:", error)
+      }
+    },
+    [enabled, permission]
+  )
+
+  return { permission, notify }
+}