@salesforce/ui-bundle-template-app-react-sample-b2x 1.117.2

package/dist/force-app/main/default/uiBundles/propertyrentalapp/src/features/object-search/utils/sortUtils.ts

@@ -0,0 +1,38 @@
+import { ResultOrder, NullOrder } from "../../../api/graphql-operations-types";
+
+export type SortFieldConfig<TFieldName extends string = string> = {
+	field: TFieldName;
+	label: string;
+};
+
+export type SortState<TFieldName extends string = string> = {
+	field: TFieldName;
+	direction: "ASC" | "DESC";
+};
+
+/**
+ * Converts a {@link SortState} into a GraphQL order-by object.
+ *
+ * @typeParam TOrderBy - The GraphQL order-by input type (e.g. `AccountOrderByInput`).
+ * @param sort - The current sort state from the UI, or `null` if no sort is applied.
+ * @returns An order-by object for the GraphQL query's `orderBy` variable, or
+ *          `undefined` if no sort is active (which uses the API's default ordering).
+ *
+ * @example
+ * ```ts
+ * const orderBy = buildOrderBy<AccountOrderByInput>({
+ *   field: "Name",
+ *   direction: "ASC",
+ * });
+ * // orderBy => { Name: { order: ResultOrder.Asc, nulls: NullOrder.Last } }
+ * ```
+ */
+export function buildOrderBy<TOrderBy>(sort: SortState | null): TOrderBy | undefined {
+	if (!sort) return undefined;
+	return {
+		[sort.field]: {
+			order: sort.direction === "ASC" ? ResultOrder.Asc : ResultOrder.Desc,
+			nulls: NullOrder.Last,
+		},
+	} as TOrderBy;
+}

package/dist/force-app/main/default/uiBundles/propertyrentalapp/src/hooks/useGeocode.ts

@@ -0,0 +1,33 @@
+import { geocodeAddress, getStateZipFromAddress, type GeocodeResult } from "@/utils/geocode";
+import { useCachedAsyncData } from "@/features/object-search/hooks/useCachedAsyncData";
+
+async function geocodeWithFallback(address: string): Promise<GeocodeResult | null> {
+	const normalized = address.replace(/\n/g, ", ").trim();
+	const result = await geocodeAddress(normalized);
+	if (result != null) return result;
+
+	// Fallback: try state + zip if full address failed
+	const stateZip = getStateZipFromAddress(normalized);
+	if (stateZip !== normalized) {
+		return geocodeAddress(stateZip);
+	}
+	return null;
+}
+
+export function useGeocode(address: string | null | undefined): {
+	coords: GeocodeResult | null;
+	loading: boolean;
+} {
+	const trimmed = address?.trim() ?? "";
+
+	const { data: coords, loading } = useCachedAsyncData(
+		() => {
+			if (!trimmed) return Promise.resolve(null);
+			return geocodeWithFallback(trimmed);
+		},
+		[trimmed],
+		{ key: `geocode:${trimmed}`, ttl: 600_000 },
+	);
+
+	return { coords, loading };
+}

package/dist/force-app/main/default/uiBundles/propertyrentalapp/src/hooks/useMaintenanceRequests.ts

@@ -0,0 +1,43 @@
+/**
+ * Fetches Maintenance_Request__c list and exposes refetch for after create.
+ */
+import { useState, useCallback } from "react";
+import {
+	searchMaintenanceRequests,
+	type MaintenanceRequestNode,
+} from "@/api/maintenanceRequests/maintenanceRequestApi";
+import { ResultOrder } from "@/api/graphql-operations-types";
+import {
+	useCachedAsyncData,
+	clearCacheEntry,
+} from "@/features/object-search/hooks/useCachedAsyncData";
+
+const CACHE_KEY = "maintenance-requests";
+
+async function fetchMaintenanceNodes(): Promise<MaintenanceRequestNode[]> {
+	const result = await searchMaintenanceRequests({
+		first: 50,
+		orderBy: { Scheduled__c: { order: ResultOrder.Desc } },
+	});
+	return (result.edges ?? []).flatMap((e) => (e?.node ? [e.node] : []));
+}
+
+export function useMaintenanceRequests(): {
+	requests: MaintenanceRequestNode[];
+	loading: boolean;
+	error: string | null;
+	refetch: () => void;
+} {
+	const [generation, setGeneration] = useState(0);
+
+	const { data, loading, error } = useCachedAsyncData(fetchMaintenanceNodes, [generation], {
+		key: `${CACHE_KEY}:${generation}`,
+	});
+
+	const refetch = useCallback(() => {
+		clearCacheEntry(`${CACHE_KEY}:${generation}`);
+		setGeneration((g) => g + 1);
+	}, [generation]);
+
+	return { requests: data ?? [], loading, error, refetch };
+}

package/dist/force-app/main/default/uiBundles/propertyrentalapp/src/hooks/usePropertyDetail.ts

@@ -0,0 +1,63 @@
+/**
+ * Fetches Property__c by id with all related data (images, costs, features, listings)
+ * in a single GraphQL query.
+ */
+import { useState, useCallback } from "react";
+import {
+	fetchPropertyDetailById,
+	fetchListingById,
+	type PropertyDetailNode,
+} from "@/api/properties/propertyDetailGraphQL";
+import {
+	useCachedAsyncData,
+	clearCacheEntry,
+} from "@/features/object-search/hooks/useCachedAsyncData";
+
+export interface PropertyDetailState {
+	property: PropertyDetailNode | null;
+	loading: boolean;
+	error: string | null;
+}
+
+const CACHE_KEY_PREFIX = "property-detail";
+
+async function fetchDetail(id: string): Promise<PropertyDetailNode | null> {
+	// First try directly as a Property__c ID (common path).
+	const detail = await fetchPropertyDetailById(id);
+	if (detail) return detail;
+
+	// Fall back: treat as a Property_Listing__c ID and resolve to its Property__c.
+	const listing = await fetchListingById(id);
+	const propertyId = listing?.Property__c?.value ?? null;
+	if (!propertyId) return null;
+	return fetchPropertyDetailById(propertyId);
+}
+
+export function usePropertyDetail(
+	id: string | undefined,
+): PropertyDetailState & { refetch: () => void } {
+	const [generation, setGeneration] = useState(0);
+	const trimmedId = id?.trim() ?? "";
+	const cacheKey = `${CACHE_KEY_PREFIX}:${trimmedId}:${generation}`;
+
+	const { data, loading, error } = useCachedAsyncData(
+		() => {
+			if (!trimmedId) return Promise.resolve(null);
+			return fetchDetail(trimmedId);
+		},
+		[trimmedId, generation],
+		{ key: cacheKey },
+	);
+
+	const refetch = useCallback(() => {
+		clearCacheEntry(cacheKey);
+		setGeneration((g) => g + 1);
+	}, [cacheKey]);
+
+	return {
+		property: data ?? null,
+		loading,
+		error,
+		refetch,
+	};
+}

package/dist/force-app/main/default/uiBundles/propertyrentalapp/src/hooks/usePropertyMapMarkers.ts

@@ -0,0 +1,181 @@
+/**
+ * Builds map markers from search result nodes. Uses coordinates when available,
+ * falls back to geocoding addresses for properties missing coordinates.
+ */
+import { useState, useEffect, useRef } from "react";
+import { fetchPropertyAddresses } from "@/api/properties/propertyDetailGraphQL";
+import { geocodeAddress, getStateZipFromAddress } from "@/utils/geocode";
+import type { PropertySearchNode } from "@/api/properties/propertySearchService";
+import type { MapMarker } from "@/components/properties/PropertyMap";
+
+function getListingName(node: PropertySearchNode): string {
+	if (node.Name?.displayValue != null && node.Name.displayValue !== "")
+		return node.Name.displayValue;
+	if (node.Name?.value != null && node.Name.value !== "") return node.Name.value;
+	return "Property";
+}
+
+function toFiniteNumber(value: unknown): number | null {
+	if (typeof value === "number" && Number.isFinite(value)) return value;
+	if (typeof value === "string" && value.trim() !== "") {
+		const n = Number(value);
+		return Number.isFinite(n) ? n : null;
+	}
+	return null;
+}
+
+function getCoordinatesFromNode(node: PropertySearchNode): { lat: number; lng: number } | null {
+	const lat = toFiniteNumber(node.Coordinates__Latitude__s?.value);
+	const lng = toFiniteNumber(node.Coordinates__Longitude__s?.value);
+	if (lat == null || lng == null) return null;
+	return { lat, lng };
+}
+
+/** Round to 5 decimals (~1 m) so near-duplicate coords group together */
+function key(lat: number, lng: number): string {
+	return `${lat.toFixed(5)},${lng.toFixed(5)}`;
+}
+
+/**
+ * When multiple markers share the same lat/lng, offset them in a small circle so they appear
+ * close together but are all visible (no stacking).
+ */
+function spreadDuplicateMarkers(markers: MapMarker[]): MapMarker[] {
+	const groups = new Map<string, MapMarker[]>();
+	for (const m of markers) {
+		const k = key(m.lat, m.lng);
+		if (!groups.has(k)) groups.set(k, []);
+		groups.get(k)!.push(m);
+	}
+	const result: MapMarker[] = [];
+	const radiusDeg = 0.0004; // ~40–50 m so pins sit close but visible
+	for (const group of groups.values()) {
+		if (group.length === 1) {
+			result.push(group[0]);
+			continue;
+		}
+		for (let i = 0; i < group.length; i++) {
+			const m = group[i];
+			const angle = (i / group.length) * 2 * Math.PI;
+			result.push({
+				...m,
+				lat: m.lat + radiusDeg * Math.cos(angle),
+				lng: m.lng + radiusDeg * Math.sin(angle),
+			});
+		}
+	}
+	return result;
+}
+
+export function usePropertyMapMarkers(results: PropertySearchNode[]): {
+	markers: MapMarker[];
+	loading: boolean;
+} {
+	const [markers, setMarkers] = useState<MapMarker[]>([]);
+	const [loading, setLoading] = useState(false);
+
+	const propertyIds = results.map((r) => r.Id).filter(Boolean);
+	const propertyIdToLabel = new Map<string, string>();
+	for (const node of results) {
+		if (!propertyIdToLabel.has(node.Id)) {
+			propertyIdToLabel.set(node.Id, getListingName(node));
+		}
+	}
+	const idsKey = [...new Set(propertyIds)].join(",");
+
+	const resultsRef = useRef(results);
+	const labelMapRef = useRef(propertyIdToLabel);
+	useEffect(() => {
+		resultsRef.current = results;
+		labelMapRef.current = propertyIdToLabel;
+	});
+
+	useEffect(() => {
+		const uniqIds = idsKey === "" ? [] : idsKey.split(",");
+		if (uniqIds.length === 0) {
+			setMarkers([]);
+			setLoading(false);
+			return;
+		}
+		let cancelled = false;
+		setLoading(true);
+		const currentLabels = labelMapRef.current;
+		const directMarkers: MapMarker[] = [];
+		const missingIds: string[] = [];
+		for (const node of results) {
+			if (!uniqIds.includes(node.Id)) continue;
+			const coords = getCoordinatesFromNode(node);
+			if (coords) {
+				directMarkers.push({
+					lat: coords.lat,
+					lng: coords.lng,
+					label: propertyIdToLabel.get(node.Id) ?? "Property",
+					propertyId: node.Id,
+				});
+			}
+		}
+		for (const id of uniqIds) {
+			const hasDirect = directMarkers.some((m) => m.propertyId === id);
+			if (!hasDirect) missingIds.push(id);
+		}
+		if (missingIds.length === 0) {
+			setMarkers(spreadDuplicateMarkers(directMarkers));
+			setLoading(false);
+			return;
+		}
+		fetchPropertyAddresses(missingIds)
+			.then((idToAddress) => {
+				if (cancelled) return;
+				const toGeocode = Object.entries(idToAddress).filter(
+					([, addr]) => addr != null && addr.trim() !== "",
+				);
+				if (toGeocode.length === 0) {
+					setMarkers(spreadDuplicateMarkers(directMarkers));
+					setLoading(false);
+					return;
+				}
+				Promise.all(
+					toGeocode.map(async ([id, address]) => {
+						const normalized = address.replace(/\n/g, ", ").trim();
+						let coords = await geocodeAddress(normalized);
+						if (!coords) {
+							const stateZip = getStateZipFromAddress(normalized);
+							if (stateZip !== normalized) {
+								coords = await geocodeAddress(stateZip);
+							}
+						}
+						return coords ? { id, coords } : null;
+					}),
+				)
+					.then((resolved) => {
+						if (cancelled) return;
+						const geocoded: MapMarker[] = resolved
+							.filter((r): r is { id: string; coords: { lat: number; lng: number } } => r != null)
+							.map(({ id, coords }) => ({
+								lat: coords.lat,
+								lng: coords.lng,
+								label: currentLabels.get(id) ?? "Property",
+								propertyId: id,
+							}));
+						setMarkers(spreadDuplicateMarkers([...directMarkers, ...geocoded]));
+					})
+					.catch(() => {
+						if (!cancelled) setMarkers([]);
+					})
+					.finally(() => {
+						if (!cancelled) setLoading(false);
+					});
+			})
+			.catch(() => {
+				if (!cancelled) {
+					setMarkers([]);
+					setLoading(false);
+				}
+			});
+		return () => {
+			cancelled = true;
+		};
+	}, [idsKey]);
+
+	return { markers, loading };
+}

package/dist/force-app/main/default/uiBundles/propertyrentalapp/src/hooks/useTenantAccess.ts

@@ -0,0 +1,38 @@
+import { useEffect, useState } from "react";
+import { hasTenantAccess } from "@/api/tenantApi";
+
+export function useTenantAccess(userId: string | undefined): {
+	hasTenantRecord: boolean;
+	loading: boolean;
+} {
+	const [hasTenantRecord, setHasTenantRecord] = useState(false);
+	const [loading, setLoading] = useState(false);
+
+	useEffect(() => {
+		const id = userId?.trim() ?? "";
+		if (!id) {
+			setHasTenantRecord(false);
+			setLoading(false);
+			return;
+		}
+
+		let cancelled = false;
+		setLoading(true);
+		hasTenantAccess(id)
+			.then((allowed) => {
+				if (!cancelled) setHasTenantRecord(allowed);
+			})
+			.catch(() => {
+				if (!cancelled) setHasTenantRecord(false);
+			})
+			.finally(() => {
+				if (!cancelled) setLoading(false);
+			});
+
+		return () => {
+			cancelled = true;
+		};
+	}, [userId]);
+
+	return { hasTenantRecord, loading };
+}

package/dist/force-app/main/default/uiBundles/propertyrentalapp/src/hooks/useWeather.ts

@@ -0,0 +1,311 @@
+/**
+ * Real weather data via Open-Meteo (free, no API key).
+ * Detects user location via Geolocation API; falls back to San Francisco.
+ */
+import { useState, useEffect } from "react";
+import { useCachedAsyncData } from "@/features/object-search/hooks/useCachedAsyncData";
+
+const FALLBACK = {
+	LAT: 37.7749,
+	LNG: -122.4194,
+	CITY: "San Francisco",
+	TIMEZONE: "America/Los_Angeles",
+} as const;
+const IMPERIAL_REGIONS = new Set(["US", "LR", "MM"]);
+const MIN_TODAY_TILES = 3;
+
+/** WMO weather codes → short label (Open-Meteo) */
+const WEATHER_LABELS: Record<number, string> = {
+	0: "Clear",
+	1: "Mainly clear",
+	2: "Partly cloudy",
+	3: "Overcast",
+	45: "Foggy",
+	48: "Depositing rime fog",
+	51: "Light drizzle",
+	53: "Drizzle",
+	55: "Dense drizzle",
+	61: "Slight rain",
+	63: "Rain",
+	65: "Heavy rain",
+	71: "Slight snow",
+	73: "Snow",
+	75: "Heavy snow",
+	77: "Snow grains",
+	80: "Slight rain showers",
+	81: "Rain showers",
+	82: "Heavy rain showers",
+	85: "Slight snow showers",
+	86: "Heavy snow showers",
+	95: "Thunderstorm",
+	96: "Thunderstorm + hail",
+	99: "Thunderstorm + heavy hail",
+};
+
+/** Splits an API timestamp like "2026-03-12T21:00" into its date and hour parts. */
+function parseTimestamp(ts: string): { dateStr: string; hour: number } {
+	const [date, time] = ts.split("T");
+	return { dateStr: date!, hour: Number(time?.split(":")[0]) };
+}
+
+/** Returns { date: "YYYY-MM-DD", hour: 0-23 } for a Date in the given IANA timezone. */
+function datePartsInTimezone(
+	date: Date,
+	timezone: string,
+	locale: string,
+): { date: string; hour: number } {
+	const fmt = new Intl.DateTimeFormat(locale, {
+		year: "numeric",
+		month: "2-digit",
+		day: "2-digit",
+		hour: "numeric",
+		hour12: false,
+		timeZone: timezone,
+	});
+	const p = Object.fromEntries(fmt.formatToParts(date).map((x) => [x.type, x.value]));
+	return { date: `${p.year}-${p.month}-${p.day}`, hour: Number(p.hour) };
+}
+
+/** Formats an hour (0-23) as a localized time string like "9 PM" or "21". */
+function formatHourLabel(hour: number, locale: string): string {
+	// Dummy date — only the hour matters. Avoids parsing API timestamps through
+	// new Date(ts), which would misinterpret them in the user's local timezone.
+	return new Date(2000, 0, 1, hour).toLocaleTimeString(locale, { hour: "numeric" });
+}
+
+/** Returns the short weekday name for a "YYYY-MM-DD" date string. */
+function weekdayLabel(dateStr: string, locale: string): string {
+	// Parse at noon UTC and format in UTC so the user's local timezone can't shift the date.
+	return new Date(dateStr + "T12:00:00Z").toLocaleDateString(locale, {
+		weekday: "short",
+		timeZone: "UTC",
+	});
+}
+
+function isImperialLocale(): boolean {
+	const region = navigator.language.split("-")[1]?.toUpperCase() ?? "";
+	return IMPERIAL_REGIONS.has(region);
+}
+
+async function reverseGeocode(lat: number, lng: number): Promise<string> {
+	try {
+		const url = `https://nominatim.openstreetmap.org/reverse?lat=${lat}&lon=${lng}&format=json&zoom=10`;
+		const response = await fetch(url, {
+			headers: { "Accept-Language": navigator.language },
+		});
+		if (!response.ok) return "";
+		const data = (await response.json()) as {
+			address?: { city?: string; town?: string; village?: string; county?: string };
+		};
+		const addr = data.address;
+		return addr?.city ?? addr?.town ?? addr?.village ?? addr?.county ?? "";
+	} catch {
+		return "";
+	}
+}
+
+export type TempUnit = "°F" | "°C";
+export type WindUnit = "mph" | "km/h";
+
+export interface WeatherCurrent {
+	description: string;
+	temp: number;
+	tempUnit: TempUnit;
+	humidity: number;
+	windSpeed: number;
+	windUnit: WindUnit;
+	weatherCode: number;
+	precipitationProbability: number;
+}
+
+export interface WeatherHour {
+	time: string;
+	temp: number;
+	weatherCode: number;
+}
+
+export interface WeatherData {
+	current: WeatherCurrent;
+	city: string;
+	todayHourly: WeatherHour[];
+	tomorrowHourly: WeatherHour[];
+	next3DaysHourly: WeatherHour[];
+	timezone: string;
+}
+
+interface OpenMeteoResponse {
+	current?: {
+		temperature_2m?: number;
+		relative_humidity_2m?: number;
+		weather_code?: number;
+		wind_speed_10m?: number;
+	};
+	hourly?: {
+		time?: string[];
+		temperature_2m?: (number | null)[];
+		weather_code?: (number | null)[];
+		precipitation_probability?: (number | null)[];
+	};
+	timezone?: string;
+}
+
+async function fetchWeather(lat: number, lng: number): Promise<WeatherData> {
+	const url = new URL("https://api.open-meteo.com/v1/forecast");
+	url.searchParams.set("latitude", String(lat));
+	url.searchParams.set("longitude", String(lng));
+	url.searchParams.set(
+		"current",
+		"temperature_2m,relative_humidity_2m,weather_code,wind_speed_10m",
+	);
+	url.searchParams.set("hourly", "temperature_2m,weather_code,precipitation_probability");
+	url.searchParams.set("timezone", "auto");
+	url.searchParams.set("forecast_days", "4");
+
+	const [response, geocodedCity] = await Promise.all([
+		fetch(url.toString()),
+		reverseGeocode(lat, lng),
+	]);
+	if (!response.ok) throw new Error(`Weather failed: ${response.status}`);
+
+	const data = (await response.json()) as OpenMeteoResponse;
+	const timezone = data.timezone ?? FALLBACK.TIMEZONE;
+	const locale = navigator.language;
+	const imperial = isImperialLocale();
+	const tempUnit: TempUnit = imperial ? "°F" : "°C";
+	const windUnit: WindUnit = imperial ? "mph" : "km/h";
+	const convertTemp = (c: number) => (imperial ? Math.round((c * 9) / 5 + 32) : Math.round(c));
+	const convertWind = (kmh: number) =>
+		imperial ? Math.round(kmh * 0.621371 * 10) / 10 : Math.round(kmh * 10) / 10;
+
+	const cur = data.current ?? {};
+	const { date: todayDateStr, hour: currentHour } = datePartsInTimezone(
+		new Date(),
+		timezone,
+		locale,
+	);
+	const [y, m, d] = todayDateStr.split("-").map(Number);
+	const tomorrowDateStr = new Date(Date.UTC(y!, m! - 1, d! + 1)).toISOString().slice(0, 10);
+
+	const {
+		time: times = [],
+		temperature_2m: temps = [],
+		weather_code: codes = [],
+		precipitation_probability: precips = [],
+	} = data.hourly ?? {};
+
+	let precipProbability = 0;
+	let foundPrecip = false;
+	const todayFuture: WeatherHour[] = [];
+	const tomorrowAll: WeatherHour[] = [];
+	const tomorrowHourly: WeatherHour[] = [];
+	const next3DaysHourly: WeatherHour[] = [];
+
+	for (let i = 0; i < times.length; i++) {
+		const ts = times[i];
+		if (!ts) continue;
+
+		const { dateStr, hour: entryHour } = parseTimestamp(ts);
+		const isFuture =
+			dateStr > todayDateStr || (dateStr === todayDateStr && entryHour >= currentHour);
+
+		if (!foundPrecip && isFuture) {
+			precipProbability = precips[i] ?? 0;
+			foundPrecip = true;
+		}
+
+		const tempC = temps[i];
+		if (tempC == null) continue;
+
+		const timeLabel = formatHourLabel(entryHour, locale);
+		const entry: WeatherHour = {
+			time: timeLabel,
+			temp: convertTemp(tempC),
+			weatherCode: codes[i] ?? 0,
+		};
+
+		if (dateStr === todayDateStr && isFuture) {
+			todayFuture.push(entry);
+		}
+		if (dateStr === tomorrowDateStr) {
+			tomorrowAll.push(entry);
+			if (entryHour % 3 === 0) {
+				tomorrowHourly.push(entry);
+			}
+		}
+		if (dateStr > todayDateStr && entryHour % 6 === 0) {
+			next3DaysHourly.push({
+				...entry,
+				time: weekdayLabel(dateStr, locale) + " " + timeLabel,
+			});
+		}
+	}
+
+	const backfill = Math.max(0, MIN_TODAY_TILES - todayFuture.length);
+	const todayHourly = [...todayFuture, ...tomorrowAll.slice(0, backfill)];
+
+	return {
+		current: {
+			description: WEATHER_LABELS[cur.weather_code ?? 0] ?? "Unknown",
+			temp: convertTemp(cur.temperature_2m ?? 0),
+			tempUnit,
+			humidity: cur.relative_humidity_2m ?? 0,
+			windSpeed: convertWind(cur.wind_speed_10m ?? 0),
+			windUnit,
+			weatherCode: cur.weather_code ?? 0,
+			precipitationProbability: precipProbability,
+		},
+		city: geocodedCity || FALLBACK.CITY,
+		todayHourly,
+		tomorrowHourly,
+		next3DaysHourly,
+		timezone,
+	};
+}
+
+interface GeoPosition {
+	latitude: number;
+	longitude: number;
+	resolved: boolean;
+}
+
+function useGeolocation(): GeoPosition {
+	const [position, setPosition] = useState<GeoPosition>(() => ({
+		latitude: FALLBACK.LAT,
+		longitude: FALLBACK.LNG,
+		resolved: typeof navigator === "undefined" || !navigator.geolocation,
+	}));
+
+	useEffect(() => {
+		if (!navigator.geolocation) return;
+		navigator.geolocation.getCurrentPosition(
+			(pos) =>
+				setPosition({
+					latitude: pos.coords.latitude,
+					longitude: pos.coords.longitude,
+					resolved: true,
+				}),
+			() => setPosition((prev) => ({ ...prev, resolved: true })),
+		);
+	}, []);
+
+	return position;
+}
+
+export function useWeather(lat?: number | null, lng?: number | null) {
+	const geo = useGeolocation();
+	const latitude = lat ?? geo.latitude;
+	const longitude = lng ?? geo.longitude;
+	const canFetch = lat != null || geo.resolved;
+
+	const cached = useCachedAsyncData(
+		() => fetchWeather(latitude, longitude),
+		[latitude, longitude, canFetch],
+		{ key: `weather:${latitude},${longitude}:${canFetch}`, ttl: 300_000 },
+	);
+
+	if (!canFetch) {
+		return { data: null, loading: true, error: null };
+	}
+
+	return { data: cached.data, loading: cached.loading, error: cached.error };
+}