Defer profile favourites until needed

resources/js/lib/useLazyProfileFavourites.js

@@ -0,0 +1,83 @@
+import { useCallback, useEffect, useRef, useState } from 'react'
+
+export default function useLazyProfileFavourites({ username, initialFavourites, enabled }) {
+  const hasInitialValue = initialFavourites !== null && initialFavourites !== undefined
+  const initialItems = Array.isArray(initialFavourites)
+    ? initialFavourites
+    : (initialFavourites?.data ?? [])
+  const [items, setItems] = useState(() => initialItems)
+  const [nextCursor, setNextCursor] = useState(() => initialFavourites?.next_cursor ?? null)
+  const [loading, setLoading] = useState(false)
+  const [error, setError] = useState(false)
+  const requestKeyRef = useRef(username)
+  const requestedRef = useRef(hasInitialValue)
+  const abortRef = useRef(null)
+
+  useEffect(() => {
+    if (requestKeyRef.current === username) return undefined
+
+    abortRef.current?.abort()
+    abortRef.current = null
+    requestKeyRef.current = username
+    requestedRef.current = false
+    setItems([])
+    setNextCursor(null)
+    setLoading(false)
+    setError(false)
+    return undefined
+  }, [username])
+
+  useEffect(() => {
+    if (requestKeyRef.current !== username || !hasInitialValue) return undefined
+
+    abortRef.current?.abort()
+    abortRef.current = null
+    requestedRef.current = true
+    setItems(initialItems)
+    setNextCursor(initialFavourites?.next_cursor ?? null)
+    setLoading(false)
+    setError(false)
+    return undefined
+  }, [hasInitialValue, initialFavourites, initialItems, username])
+
+  const load = useCallback(async () => {
+    if (!enabled || hasInitialValue || requestedRef.current || !username) return
+
+    requestedRef.current = true
+    const controller = new AbortController()
+    const requestKey = requestKeyRef.current
+    abortRef.current = controller
+    setLoading(true)
+    setError(false)
+
+    try {
+      const response = await fetch(`/api/profile/${encodeURIComponent(username)}/favourites`, {
+        headers: { Accept: 'application/json' },
+        credentials: 'same-origin',
+        signal: controller.signal,
+      })
+      if (!response.ok) throw new Error('Favourites could not be loaded.')
+      const payload = await response.json()
+      if (requestKey !== requestKeyRef.current || controller.signal.aborted) return
+      setItems(Array.isArray(payload?.data) ? payload.data : [])
+      setNextCursor(payload?.next_cursor ?? null)
+    } catch (caught) {
+      if (caught?.name === 'AbortError' || requestKey !== requestKeyRef.current) return
+      requestedRef.current = false
+      setError(true)
+    } finally {
+      if (requestKey === requestKeyRef.current) {
+        abortRef.current = null
+        setLoading(false)
+      }
+    }
+  }, [enabled, hasInitialValue, username])
+
+  useEffect(() => {
+    if (enabled) load()
+  }, [enabled, load])
+
+  useEffect(() => () => abortRef.current?.abort(), [])
+
+  return { items, nextCursor, loading, error, retry: load }
+}

resources/js/lib/useLazyProfileFavourites.test.jsx

@@ -0,0 +1,74 @@
+import React from 'react'
+import { render, waitFor } from '@testing-library/react'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import useLazyProfileFavourites from './useLazyProfileFavourites'
+
+function Harness({ username = 'alice', initial = null, enabled = false }) {
+  const state = useLazyProfileFavourites({
+    username,
+    initialFavourites: initial,
+    enabled,
+  })
+
+  return <output data-testid="state">{JSON.stringify(state)}</output>
+}
+
+describe('useLazyProfileFavourites', () => {
+  beforeEach(() => {
+    vi.restoreAllMocks()
+  })
+
+  it('does not request before activation and requests page one once on activation', async () => {
+    const fetchMock = vi.spyOn(globalThis, 'fetch').mockResolvedValue({
+      ok: true,
+      json: async () => ({ data: [{ id: 1 }], next_cursor: 'c1' }),
+    })
+    const view = render(<Harness />)
+
+    expect(fetchMock).not.toHaveBeenCalled()
+    view.rerender(<Harness enabled />)
+
+    await waitFor(() => expect(fetchMock).toHaveBeenCalledTimes(1))
+    expect(fetchMock).toHaveBeenCalledWith('/api/profile/alice/favourites', expect.objectContaining({
+      credentials: 'same-origin',
+    }))
+  })
+
+  it('uses SSR data without a page-one request and survives rerenders', async () => {
+    const fetchMock = vi.spyOn(globalThis, 'fetch')
+    const view = render(<Harness enabled initial={{ data: [{ id: 9 }], next_cursor: 'c2' }} />)
+    view.rerender(<Harness enabled initial={{ data: [{ id: 9 }], next_cursor: 'c2' }} />)
+
+    await waitFor(() => expect(JSON.parse(view.getByTestId('state').textContent).items).toEqual([{ id: 9 }]))
+    expect(fetchMock).not.toHaveBeenCalled()
+  })
+
+  it('does not refetch after switching away and back', async () => {
+    const fetchMock = vi.spyOn(globalThis, 'fetch').mockResolvedValue({
+      ok: true,
+      json: async () => ({ data: [{ id: 3 }], next_cursor: null }),
+    })
+    const view = render(<Harness enabled />)
+    await waitFor(() => expect(fetchMock).toHaveBeenCalledTimes(1))
+
+    view.rerender(<Harness enabled={false} />)
+    view.rerender(<Harness enabled />)
+    await waitFor(() => expect(JSON.parse(view.getByTestId('state').textContent).items).toEqual([{ id: 3 }]))
+    expect(fetchMock).toHaveBeenCalledTimes(1)
+  })
+
+  it('resets profile state and ignores a stale response', async () => {
+    let resolveRequest
+    const fetchMock = vi.spyOn(globalThis, 'fetch').mockImplementation(() => new Promise((resolve) => {
+      resolveRequest = resolve
+    }))
+    const view = render(<Harness username="alice" enabled />)
+    await waitFor(() => expect(fetchMock).toHaveBeenCalledTimes(1))
+
+    view.rerender(<Harness username="bob" enabled />)
+    expect(JSON.parse(view.getByTestId('state').textContent).items).toEqual([])
+    resolveRequest({ ok: true, json: async () => ({ data: [{ id: 1 }], next_cursor: null }) })
+
+    await waitFor(() => expect(JSON.parse(view.getByTestId('state').textContent).items).toEqual([]))
+  })
+})