Typescript useFetch

useFetch.ts

// mocks

const mockUser = {}
const mockGoals = []

// endpoint
    
enum ApiEndpoint {
    FetchAllGoals = '/goals',
    CurrentUser = '/user',
}


// fetcher

const fetchUserGoals = (): Promise<Goal[]> =>
    new Promise((res) => {
        setTimeout(() => res(mockGoals), 250);
    });

const currentUser = (): Promise<User> =>
    new Promise((res) => {
        setTimeout(() => res(mockUser), 250);
    });    

// useFetch

const endpointToPromiseMap = {
    [ApiEndpoint.FetchAllGoals]: fetchUserGoals,
    [ApiEndpoint.CurrentUser]: currentUser,
};

// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
const useFetch = <V>(endpoint: ApiEndpoint, args?: V) => {
    const prms = endpointToPromiseMap[endpoint];
    return _useFetch(prms, args);
};

// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
const _useFetch = <T, L>(prms: (arg0?: L) => Promise<T>, args?: L) => {
    const isMounted = useRef(true);
    const [data, setData] = useState<T | null>(null);
    const [errorMessage, setErrorMessage] = useState<string>('');
    const [status, setStatus] = useState<FetchStatus>(FetchStatus.Loading);

    useEffect(() => {
        const fn = async () => {
            try {
                setStatus(FetchStatus.Loading);
                const payload = await prms(args);
                if (isMounted) {
                    setData(payload);
                    setStatus(FetchStatus.Success);
                }
            } catch (err) {
                if (isMounted) {
                    setErrorMessage(err.message);
                    setStatus(FetchStatus.Failed);
                }
            }
        };
        fn();

        return () => {
            isMounted.current = false;
        };
    }, []);

    return {
        status,
        errorMessage,
        data,
    };
};