freshyo/apps/user-ui/src/hooks/useRegion.ts
2026-10-13 18:11:25 +05:30

278 lines
11 KiB
TypeScript

import { useEffect, useMemo, useState } from 'react'
import { useQueryClient } from '@tanstack/react-query'
import type { RegionSummary, RegionBoundSummary } from '@packages/shared'
import { useRegionStore } from '@/src/store/regionStore'
import { useLocationStore } from '@/src/store/locationStore'
import { trpc } from '@/src/trpc-client'
import { confirmRegionSwitch } from '@/src/lib/region-switch'
import { useAuthOptional } from '@/src/contexts/AuthContext'
// Give up on the backend resolve and fall back to the saved region / chooser.
const RESOLVE_TIMEOUT_MS = 8000
// The startup location check runs ONCE per app launch, no matter how many
// components consume `useRegion`. `startupCheckDone` is the single-flight guard
// for the switch itself; `startupLaunchRegionId` records the region at launch so
// a manual pick made before the fix lands is respected.
let startupCheckDone = false
let startupLaunchRegionId: number | null | undefined
/**
* The single source of truth for the browsing region ("location").
*
* EVERY component/hook that needs to read or change the current region must go
* through this hook instead of touching `useRegionStore` / `useLocationStore`
* directly, so the location bar, the region gate, checkout and the regional API
* hooks can never drift out of sync.
*
* On every launch the hook takes ONE device fix (no movement tracking) and
* resolves it to a region. The active bound is NOT taken from the location; it is
* the least-priority bound among the user's addresses in that region (else the
* region's effective bound). If the resolved region differs from the saved one
* the region is switched (clears carts, refreshes region-scoped data). When the
* location is unusable the saved region is kept, or the chooser is shown.
*/
export interface UseRegionResult {
/** The region the user is currently browsing. `null` until one is chosen. */
region: RegionSummary | null
/** Convenience alias for `region?.id`. `null` until a region is chosen. */
regionId: number | null
/** The bound whose consts the client reads for this region. `null` until known. */
boundId: number | null
/** The bound the launch location fell inside, when it resolved the region. */
bound: RegionBoundSummary | null
/** Monotonic marker bumped on every region change; use it to ignore stale responses. */
regionGeneration: number
/** Always true: the region store is in-memory (not persisted). */
hydrated: boolean
/** Latest device coordinates, if the launch fix succeeded. */
coords: { latitude: number; longitude: number } | null
/** Current state of the launch location read. */
locationStatus: 'idle' | 'locating' | 'granted' | 'denied' | 'services-off' | 'unavailable' | 'error'
/**
* True while the launch location check is still determining a region AND no
* region is known yet. The UI should show a spinner rather than the chooser
* while this is true. It never becomes true again after the check settles.
*/
isResolvingRegion: boolean
/** Persist a new browsing region. For user-facing switches prefer `confirmRegionSwitch`. */
setRegion: (region: RegionSummary, boundId?: number | null) => void
/** Forget the browsing region (forces the region gate to prompt again). */
clearRegion: () => void
/** Re-check permission and take a fresh fix (e.g. a "use my location" button). */
refreshLocation: () => void
}
export function useRegion(): UseRegionResult {
const queryClient = useQueryClient()
const auth = useAuthOptional()
const isAuthenticated = auth?.isAuthenticated ?? false
const isAuthLoading = auth?.isLoading ?? false
const region = useRegionStore((state) => state.selectedRegion)
const regionId = useRegionStore((state) => state.selectedRegionId)
const storedBoundId = useRegionStore((state) => state.selectedBoundId)
const regionGeneration = useRegionStore((state) => state.regionGeneration)
const setRegion = useRegionStore((state) => state.setRegion)
const clearRegion = useRegionStore((state) => state.clearRegion)
const coords = useLocationStore((state) => state.coords)
const locationStatus = useLocationStore((state) => state.status)
const startTracking = useLocationStore((state) => state.start)
const refreshTracking = useLocationStore((state) => state.refresh)
// The region store is in-memory (not persisted), so there is nothing to
// hydrate before we can decide.
const hydrated = true
// True once the launch location check has a definitive outcome.
const [startupResolved, setStartupResolved] = useState(false)
// The user's default address — the anchor for the startup region decision.
const defaultAddressQuery = trpc.user.address.getDefaultAddress.useQuery(undefined, {
enabled: hydrated && isAuthenticated,
staleTime: 60000,
})
const defaultAddress = defaultAddressQuery.data?.data ?? null
// Region summaries (needed to build the RegionSummary when adopting a region
// from the default address).
const regionsQuery = trpc.common.listRegions.useQuery(undefined, {
enabled: hydrated,
staleTime: 60000,
})
const regions = regionsQuery.data ?? null
// Active bound = the least-priority bound among the user's addresses in the
// region, else the region's effective bound. Derived server-side (the client
// does not know bound priorities).
const activeBoundQuery = trpc.common.activeBound.useQuery(
{ regionId: regionId ?? 0 },
{ enabled: hydrated && regionId != null, staleTime: 60000 }
)
const activeBoundId = activeBoundQuery.data?.boundId ?? region?.effectiveBoundId ?? null
// Keep the stored bound in sync with the derived active bound (region-level).
useEffect(() => {
if (regionId == null || !region) return
// Only fill in a MISSING bound. Never overwrite a bound already resolved
// from the device location or a chosen address: those win at startup.
if (storedBoundId == null && activeBoundId != null) {
setRegion(region, activeBoundId)
}
}, [regionId, region, activeBoundId, storedBoundId, setRegion])
const boundId = storedBoundId ?? activeBoundId
// Take the single launch fix — even when a region is already saved, so a
// device that has moved to another region is detected on startup.
useEffect(() => {
if (!hydrated) return
if (startupLaunchRegionId === undefined) startupLaunchRegionId = regionId
startTracking()
}, [hydrated, regionId, startTracking])
// Stable, rounded input so GPS jitter doesn't churn the query key.
const lat = coords ? Math.round(coords.latitude * 1e5) / 1e5 : 0
const lng = coords ? Math.round(coords.longitude * 1e5) / 1e5 : 0
const queryInput = useMemo(() => ({ lat, lng }), [lat, lng])
const shouldResolve = hydrated && coords != null && !startupResolved
const resolution = trpc.common.resolveRegionByLocation.useQuery(queryInput, {
enabled: shouldResolve,
staleTime: Infinity,
retry: false,
refetchOnWindowFocus: false,
})
// Apply the launch outcome once. The default address anchors the decision:
// - location resolves to the default's region, or to no serviceable region
// (location off / out of area) -> use the default address;
// - location resolves to a DIFFERENT serviceable region -> let the user pick.
// Without a default address we keep the previous behaviour (use the resolved
// region, else let the user pick).
useEffect(() => {
if (!hydrated || startupResolved) return
const resolved = resolution.data
const locationSettled =
resolved != null ||
resolution.isFetched ||
resolution.isError ||
locationStatus === 'denied' ||
locationStatus === 'services-off' ||
locationStatus === 'unavailable' ||
locationStatus === 'error'
if (!locationSettled) return
// Wait for auth to settle so signed-in users can anchor on the default
// address (otherwise we'd settle with isAuthenticated=false and never
// reconsider).
if (isAuthLoading) return
// Signed-in users: wait for the default address (+ regions) so the decision
// is anchored correctly before we settle.
if (isAuthenticated) {
if (defaultAddressQuery.isLoading) return
if (defaultAddress?.regionId != null && !regions) return
}
setStartupResolved(true)
// Only one consumer performs the switch; the rest just settle their spinner.
if (startupCheckDone) return
startupCheckDone = true
// Respect a manual pick made before the fix resolved.
const userChangedRegion =
startupLaunchRegionId !== undefined && startupLaunchRegionId !== regionId
if (userChangedRegion) return
const defaultRegionId = isAuthenticated ? defaultAddress?.regionId ?? null : null
if (defaultRegionId != null) {
const inDefaultRegion = resolved?.region?.id === defaultRegionId
// No serviceable region found -> treat like a disabled location.
const noServiceableRegion = resolved == null
if (inDefaultRegion || noServiceableRegion) {
const region = regions?.find((candidate) => candidate.id === defaultRegionId) ?? null
if (region) {
if (regionId == null) {
// First region of this launch — adopt it without clearing the cart.
setRegion(region, defaultAddress?.boundId ?? null)
} else if (region.id !== regionId) {
void confirmRegionSwitch(region, queryClient, defaultAddress?.boundId ?? null)
} else if (defaultAddress?.boundId != null && defaultAddress.boundId !== boundId) {
setRegion(region, defaultAddress.boundId)
}
}
return
}
// Location is in another serviceable region -> ask the user to choose.
if (regionId != null) clearRegion()
return
}
// No default address: derive the region from the location as before.
if (resolved?.region) {
if (regionId == null) {
// First region of this launch — adopt it without clearing the cart.
setRegion(resolved.region, resolved.bound?.id ?? null)
} else if (resolved.region.id !== regionId) {
void confirmRegionSwitch(resolved.region, queryClient, resolved.bound?.id ?? null)
} else if (resolved.bound && resolved.bound.id !== boundId) {
setRegion(resolved.region, resolved.bound.id)
}
}
}, [
hydrated,
startupResolved,
resolution.data,
resolution.isFetched,
resolution.isError,
locationStatus,
regionId,
boundId,
setRegion,
clearRegion,
queryClient,
isAuthenticated,
isAuthLoading,
defaultAddressQuery.isLoading,
defaultAddress,
regions,
])
// Safety net: a hanging resolve must not strand the first-run spinner.
useEffect(() => {
if (!hydrated || startupResolved || !shouldResolve) return
const timer = setTimeout(() => {
startupCheckDone = true
setStartupResolved(true)
}, RESOLVE_TIMEOUT_MS)
return () => clearTimeout(timer)
}, [hydrated, startupResolved, shouldResolve])
const isResolvingRegion = regionId == null && !startupResolved
return {
region,
regionId,
boundId,
bound: resolution.data?.bound ?? null,
regionGeneration,
hydrated,
coords,
locationStatus,
isResolvingRegion,
setRegion,
clearRegion,
refreshLocation: () => {
// Manual re-check: re-arm the launch check so a differing region switches.
startupCheckDone = false
startupLaunchRegionId = regionId
setStartupResolved(false)
void refreshTracking()
},
}
}