arbret/frontend/app/hooks/useAsyncData.ts

import { useState, useEffect, useCallback, useRef } from "react";

/**
 * Hook for fetching async data with loading and error states.
 * Handles the common pattern of fetching data when component mounts or dependencies change.
 *
 * @param fetcher - Function that returns a Promise with the data
 * @param options - Configuration options
 * @returns Object containing data, loading state, error, and refetch function
 */
export function useAsyncData<T>(
  fetcher: () => Promise<T>,
  options: {
    /** Whether the fetch should be enabled (default: true) */
    enabled?: boolean;
    /** Callback for handling errors */
    onError?: (err: unknown) => void;
    /** Initial data value (useful for optimistic updates) */
    initialData?: T;
  } = {}
): {
  data: T | null;
  isLoading: boolean;
  error: string | null;
  refetch: () => Promise<void>;
} {
  const { enabled = true, onError, initialData } = options;

  const [data, setData] = useState<T | null>(initialData ?? null);
  const [isLoading, setIsLoading] = useState(true);
  const [error, setError] = useState<string | null>(null);

  // Use ref to store the latest fetcher function to avoid dependency issues
  const fetcherRef = useRef(fetcher);
  const onErrorRef = useRef(onError);

  // Update refs when values change
  useEffect(() => {
    fetcherRef.current = fetcher;
    onErrorRef.current = onError;
  }, [fetcher, onError]);

  const fetchData = useCallback(async () => {
    if (!enabled) return;

    setIsLoading(true);
    setError(null);

    try {
      const result = await fetcherRef.current();
      setData(result);
    } catch (err) {
      const errorMessage = err instanceof Error ? err.message : "Failed to load data";
      setError(errorMessage);
      if (onErrorRef.current) {
        onErrorRef.current(err);
      } else {
        console.error("Failed to fetch data:", err);
      }
    } finally {
      setIsLoading(false);
    }
  }, [enabled]);

  useEffect(() => {
    fetchData();
  }, [fetchData]);

  return {
    data,
    isLoading,
    error,
    refetch: fetchData,
  };
}