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

package/dist/force-app/main/default/uiBundles/propertyrentalapp/src/routes.tsx

@@ -0,0 +1,130 @@
+import type { RouteObject } from 'react-router';
+import Home from '@/pages/Home';
+import NotFound from '@/pages/NotFound';
+import AccountSearch from "./features/object-search/__examples__/pages/AccountSearch";
+import AccountObjectDetail from "./features/object-search/__examples__/pages/AccountObjectDetailPage";
+import AuthAppLayout from "./features/authentication/layouts/AuthAppLayout";
+import Login from "./features/authentication/pages/Login";
+import Register from "./features/authentication/pages/Register";
+import ForgotPassword from "./features/authentication/pages/ForgotPassword";
+import ResetPassword from "./features/authentication/pages/ResetPassword";
+import Profile from "./features/authentication/pages/Profile";
+import ChangePassword from "./features/authentication/pages/ChangePassword";
+import AuthenticationRoute from "./features/authentication/layouts/authenticationRouteLayout";
+import PrivateRoute from "./features/authentication/layouts/privateRouteLayout";
+import { ROUTES } from "./features/authentication/authenticationConfig";
+import Dashboard from "@/pages/Dashboard";
+import Maintenance from "@/pages/Maintenance";
+import PropertySearch from "@/pages/PropertySearch";
+import PropertyDetails from "@/pages/PropertyDetails";
+import Application from "@/pages/Application";
+import Contact from "@/pages/Contact";
+import TenantRoute from "./features/authentication/layouts/TenantRoute";
+
+export const routes: RouteObject[] = [
+  {
+    path: "/",
+    element: <AuthAppLayout />,
+    children: [
+      {
+        index: true,
+        element: <Home />,
+        handle: { showInNavigation: true, label: "Home" }
+      },
+      {
+        path: "*",
+        element: <NotFound />
+      },
+      {
+        path: "accounts/:recordId",
+        element: <AccountObjectDetail />
+      },
+      {
+        path: "accounts",
+        element: <AccountSearch />
+      },
+      {
+        element: <AuthenticationRoute />,
+        children: [
+          {
+            path: ROUTES.LOGIN.PATH,
+            element: <Login />,
+            handle: { showInNavigation: true, label: "Login", title: ROUTES.LOGIN.TITLE }
+          },
+          {
+            path: ROUTES.REGISTER.PATH,
+            element: <Register />,
+            handle: { showInNavigation: false, title: ROUTES.REGISTER.TITLE }
+          },
+          {
+            path: ROUTES.FORGOT_PASSWORD.PATH,
+            element: <ForgotPassword />,
+            handle: { showInNavigation: false, title: ROUTES.FORGOT_PASSWORD.TITLE }
+          },
+          {
+            path: ROUTES.RESET_PASSWORD.PATH,
+            element: <ResetPassword />,
+            handle: { showInNavigation: false, title: ROUTES.RESET_PASSWORD.TITLE }
+          }
+        ]
+      },
+      {
+        element: <PrivateRoute showCardSkeleton />,
+        children: [
+          {
+            path: ROUTES.PROFILE.PATH,
+            element: <Profile />,
+            handle: { showInNavigation: true, label: "Profile", title: ROUTES.PROFILE.TITLE }
+          },
+          {
+            path: ROUTES.CHANGE_PASSWORD.PATH,
+            element: <ChangePassword />,
+            handle: { showInNavigation: false, title: ROUTES.CHANGE_PASSWORD.TITLE }
+          }
+        ]
+      },
+      {
+        path: "properties",
+        element: <PropertySearch />,
+        handle: { showInNavigation: true, label: "Property Search" }
+      },
+      {
+        path: "property/:id",
+        element: <PropertyDetails />
+      },
+      {
+        path: "object/Property_Listing__c/:id",
+        element: <PropertyDetails />
+      },
+      {
+        path: "contact",
+        element: <Contact />,
+        handle: { showInNavigation: true, label: "Contact" }
+      },
+      {
+        element: <PrivateRoute />,
+        children: [
+          {
+            path: "application",
+            element: <Application />
+          }
+        ]
+      },
+      {
+        element: <TenantRoute />,
+        children: [
+          {
+            path: "dashboard",
+            element: <Dashboard />,
+            handle: { showInNavigation: true, label: "Dashboard" }
+          },
+          {
+            path: "maintenance",
+            element: <Maintenance />,
+            handle: { showInNavigation: true, label: "Maintenance" }
+          }
+        ]
+      }
+    ]
+  }
+];

package/dist/force-app/main/default/uiBundles/propertyrentalapp/src/styles/global.css

@@ -0,0 +1,229 @@
+@import 'tailwindcss';
+
+@layer base {
+  html,
+  body,
+  #root {
+    @apply min-h-screen;
+  }
+
+  body {
+    @apply antialiased bg-white;
+  }
+}
+
+@import 'tw-animate-css';
+@import 'shadcn/tailwind.css';
+
+@custom-variant dark (&:is(.dark *));
+
+@theme inline {
+  --color-background: var(--background);
+  --color-foreground: var(--foreground);
+  --color-card: var(--card);
+  --color-card-foreground: var(--card-foreground);
+  --color-popover: var(--popover);
+  --color-popover-foreground: var(--popover-foreground);
+  --color-primary: var(--primary);
+  --color-primary-foreground: var(--primary-foreground);
+  --color-secondary: var(--secondary);
+  --color-secondary-foreground: var(--secondary-foreground);
+  --color-muted: var(--muted);
+  --color-muted-foreground: var(--muted-foreground);
+  --color-accent: var(--accent);
+  --color-accent-foreground: var(--accent-foreground);
+  --color-destructive: var(--destructive);
+  --color-destructive-foreground: var(--destructive-foreground);
+  --color-border: var(--border);
+  --color-input: var(--input);
+  --color-ring: var(--ring);
+  --color-chart-1: var(--chart-1);
+  --color-chart-2: var(--chart-2);
+  --color-chart-3: var(--chart-3);
+  --color-chart-4: var(--chart-4);
+  --color-chart-5: var(--chart-5);
+  --radius-sm: calc(var(--radius) - 4px);
+  --radius-md: calc(var(--radius) - 2px);
+  --radius-lg: var(--radius);
+  --radius-xl: calc(var(--radius) + 4px);
+  --color-sidebar: var(--sidebar);
+  --color-sidebar-foreground: var(--sidebar-foreground);
+  --color-sidebar-primary: var(--sidebar-primary);
+  --color-sidebar-primary-foreground: var(--sidebar-primary-foreground);
+  --color-sidebar-accent: var(--sidebar-accent);
+  --color-sidebar-accent-foreground: var(--sidebar-accent-foreground);
+  --color-sidebar-border: var(--sidebar-border);
+  --color-sidebar-ring: var(--sidebar-ring);
+}
+
+:root {
+  --radius: 0.625rem;
+  --background: oklch(1 0 0);
+  --foreground: oklch(0.145 0 0);
+  --card: oklch(1 0 0);
+  --card-foreground: oklch(0.145 0 0);
+  --popover: oklch(1 0 0);
+  --popover-foreground: oklch(0.145 0 0);
+  --primary: oklch(0.205 0 0);
+  --primary-foreground: oklch(0.985 0 0);
+  --secondary: oklch(0.97 0 0);
+  --secondary-foreground: oklch(0.205 0 0);
+  --muted: oklch(0.97 0 0);
+  --muted-foreground: oklch(0.556 0 0);
+  --accent: oklch(0.97 0 0);
+  --accent-foreground: oklch(0.205 0 0);
+  --destructive: oklch(0.577 0.245 27.325);
+  --border: oklch(0.922 0 0);
+  --input: oklch(0.922 0 0);
+  --ring: oklch(0.708 0 0);
+  --chart-1: oklch(0.646 0.222 41.116);
+  --chart-2: oklch(0.6 0.118 184.704);
+  --chart-3: oklch(0.398 0.07 227.392);
+  --chart-4: oklch(0.828 0.189 84.429);
+  --chart-5: oklch(0.769 0.188 70.08);
+  --sidebar: oklch(0.985 0 0);
+  --sidebar-foreground: oklch(0.145 0 0);
+  --sidebar-primary: oklch(0.205 0 0);
+  --sidebar-primary-foreground: oklch(0.985 0 0);
+  --sidebar-accent: oklch(0.97 0 0);
+  --sidebar-accent-foreground: oklch(0.205 0 0);
+  --sidebar-border: oklch(0.922 0 0);
+  --sidebar-ring: oklch(0.708 0 0);
+}
+
+.dark {
+  --background: oklch(0.145 0 0);
+  --foreground: oklch(0.985 0 0);
+  --card: oklch(0.205 0 0);
+  --card-foreground: oklch(0.985 0 0);
+  --popover: oklch(0.205 0 0);
+  --popover-foreground: oklch(0.985 0 0);
+  --primary: oklch(0.922 0 0);
+  --primary-foreground: oklch(0.205 0 0);
+  --secondary: oklch(0.269 0 0);
+  --secondary-foreground: oklch(0.985 0 0);
+  --muted: oklch(0.269 0 0);
+  --muted-foreground: oklch(0.708 0 0);
+  --accent: oklch(0.269 0 0);
+  --accent-foreground: oklch(0.985 0 0);
+  --destructive: oklch(0.704 0.191 22.216);
+  --border: oklch(1 0 0 / 10%);
+  --input: oklch(1 0 0 / 15%);
+  --ring: oklch(0.556 0 0);
+  --chart-1: oklch(0.488 0.243 264.376);
+  --chart-2: oklch(0.696 0.17 162.48);
+  --chart-3: oklch(0.769 0.188 70.08);
+  --chart-4: oklch(0.627 0.265 303.9);
+  --chart-5: oklch(0.645 0.246 16.439);
+  --sidebar: oklch(0.205 0 0);
+  --sidebar-foreground: oklch(0.985 0 0);
+  --sidebar-primary: oklch(0.488 0.243 264.376);
+  --sidebar-primary-foreground: oklch(0.985 0 0);
+  --sidebar-accent: oklch(0.269 0 0);
+  --sidebar-accent-foreground: oklch(0.985 0 0);
+  --sidebar-border: oklch(1 0 0 / 10%);
+  --sidebar-ring: oklch(0.556 0 0);
+}
+
+@layer base {
+  * {
+    @apply border-border outline-ring/50;
+  }
+  body {
+    @apply bg-background text-foreground;
+  }
+}
+
+/* ZENLEASE design language: teal primary, cream background, soft rounded corners */
+
+:root {
+	/* Primary: deep teal (#20888F / #2c8a8d) */
+	--primary: oklch(0.52 0.09 192);
+	--primary-foreground: oklch(0.985 0 0);
+	/* Background: warm cream (#F8F6F1) */
+	--background: oklch(0.97 0.01 85);
+	--foreground: oklch(0.21 0.02 260);
+	/* Card: white with subtle warmth */
+	--card: oklch(1 0 0);
+	--card-foreground: oklch(0.21 0.02 260);
+	/* Muted: light cream for secondary surfaces */
+	--muted: oklch(0.955 0.01 85);
+	--muted-foreground: oklch(0.48 0.02 260);
+	/* Accent: used by Skeleton and other neutral surfaces; needs visibility against white cards */
+	--accent: oklch(0.92 0.01 85);
+	--accent-foreground: oklch(0.21 0.02 260);
+	/* Border / input: soft teal-tinted gray */
+	--border: oklch(0.91 0.02 192);
+	--input: oklch(0.91 0.02 192);
+	--ring: oklch(0.52 0.09 192);
+	/* Slightly larger radius for soft, friendly feel (screenshots use 16–24px) */
+	--radius: 0.75rem;
+}
+
+body {
+	@apply bg-background text-foreground;
+}
+
+@layer base {
+	* {
+		font-family: "Jost", sans-serif !important;
+	}
+
+	html,
+	body,
+	#root {
+		font-family: "Jost", sans-serif !important;
+	}
+
+	h1,
+	h2,
+	h3,
+	h4,
+	h5,
+	h6,
+	p,
+	span,
+	div,
+	a,
+	button,
+	input,
+	select,
+	textarea {
+		font-family: "Jost", sans-serif !important;
+	}
+}
+
+@layer components {
+	.text-primary-teal {
+		color: var(--primary);
+	}
+}
+
+/* Leaflet map pin (PropertyMap): Lucide-style MapPin, teal stroke */
+.property-map-pin {
+	border: none !important;
+	background: transparent !important;
+	color: var(--primary);
+	filter: drop-shadow(0 2px 4px rgba(0, 0, 0, 0.25));
+}
+.property-map-pin svg {
+	display: block;
+}
+
+/* Leaflet popup: no extra white box; close button is drawn inside content */
+.leaflet-popup-content-wrapper {
+	background: transparent !important;
+	box-shadow: none !important;
+	border: none !important;
+	padding: 0 !important;
+}
+.leaflet-popup-content {
+	margin: 0 !important;
+	min-width: 0 !important;
+}
+.leaflet-popup-close-button {
+	display: none !important;
+}
+.leaflet-popup-tip {
+	display: none !important;
+}

package/dist/force-app/main/default/uiBundles/propertyrentalapp/src/types/leaflet.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Type declarations for leaflet and react-leaflet when types are not installed in the type-check context.
+ * The app lists these in feature packageJson; this file satisfies TypeScript during source builds.
+ */
+declare module "leaflet" {
+	const L: Record<string, unknown>;
+	export default L;
+}
+
+declare module "react-leaflet" {
+	import type { ComponentType } from "react";
+	export const MapContainer: ComponentType<Record<string, unknown>>;
+	export const TileLayer: ComponentType<Record<string, unknown>>;
+	export const Marker: ComponentType<Record<string, unknown>>;
+	export const Popup: ComponentType<Record<string, unknown>>;
+	export function useMap(): Record<string, unknown>;
+}

package/dist/force-app/main/default/uiBundles/propertyrentalapp/src/types/searchResults.ts

@@ -0,0 +1,229 @@
+import { z } from "zod";
+
+/**
+ * Type definitions for search results and column structures.
+ * * ARCHITECTURE NOTE:
+ * We define recursive interfaces MANUALLY first.
+ * If we rely on z.infer<typeof LazySchema> where the schema is z.ZodTypeAny,
+ * TypeScript defaults the type to 'any', destroying type safety.
+ */
+export type ComplexFieldValue = {
+	apiName?: string;
+	childRelationships?: Record<string, unknown>;
+	eTag?: string;
+	fields?: Record<string, FieldValue>; // Recursive reference
+	id?: string;
+	lastModifiedById?: string | null;
+	lastModifiedDate?: string | null;
+	recordTypeId?: string | null;
+	recordTypeInfo?: unknown;
+	systemModstamp?: string | null;
+	weakEtag?: number;
+};
+export type FieldValue = {
+	displayValue: string | null;
+	value: string | number | boolean | null | ComplexFieldValue; // Recursive union
+};
+
+// Zod Schema for Inline Edit Attributes
+export const InlineEditAttributesSchema = z.record(
+	z.string(),
+	z.object({
+		editable: z.boolean(),
+		required: z.boolean(),
+	}),
+);
+
+/**
+ * Inline edit attributes for a field
+ */
+export type InlineEditAttributes = z.infer<typeof InlineEditAttributesSchema>;
+
+// Zod Schema for Column
+export const ColumnSchema = z.object({
+	fieldApiName: z.string(),
+	inlineEditAttributes: InlineEditAttributesSchema.optional(),
+	label: z.string(),
+	lookupId: z.string().nullish(),
+	searchable: z.boolean(),
+	sortable: z.boolean(),
+});
+
+/**
+ * Column definition for list/result UI. Can be derived from Filter[] via targetFieldPath and label
+ * (e.g. filters.map(f => ({ fieldApiName: f.targetFieldPath, label: f.label, searchable: true, sortable: true }))).
+ */
+export type Column = z.infer<typeof ColumnSchema>;
+
+// Export schema for validation
+export const ColumnArraySchema = z.array(ColumnSchema);
+
+// Zod Schema for Complex Field Value (recursive structure)
+// Using z.lazy() to handle circular reference with FieldValueSchema
+// Note: This schema is exported for advanced use cases but should be used carefully
+// due to potential performance implications with deeply nested structures
+export const ComplexFieldValueSchema: z.ZodType<ComplexFieldValue> = z.lazy(() =>
+	z.object({
+		apiName: z.string().optional(),
+		childRelationships: z.record(z.string(), z.unknown()).optional(),
+		eTag: z.string().optional(),
+		fields: z.record(z.string(), FieldValueSchema).optional(),
+		id: z.string().optional(),
+		lastModifiedById: z.string().nullish(),
+		lastModifiedDate: z.string().nullish(),
+		recordTypeId: z.string().nullish(),
+		recordTypeInfo: z.unknown().optional(),
+		systemModstamp: z.string().nullish(),
+		weakEtag: z.number().optional(),
+	}),
+);
+
+// Zod Schema for Field Value (using z.lazy() to handle circular reference)
+// Note: This schema is exported for validating individual field values on-demand
+// Use FieldValueValidationSchema alias for clarity
+// Using z.union([z.string(), z.null()]) instead of .nullish() to match FieldValue type definition
+export const FieldValueSchema: z.ZodType<FieldValue> = z.lazy(() =>
+	z.object({
+		displayValue: z.union([z.string(), z.null()]),
+		value: z.union([
+			z.string(),
+			z.number(),
+			z.boolean(),
+			z.null(),
+			ComplexFieldValueSchema as z.ZodType<ComplexFieldValue>,
+		]),
+	}),
+);
+
+// Zod Schema for Search Result Record Data (lightweight validation)
+// Using z.unknown() for fields to avoid expensive recursive validation of every field value
+// This prevents UI freezing when validating large result sets (e.g., 100 records × 50 fields = 5,000 validations)
+// Individual fields can be validated later when needed using FieldValueSchema
+// Note: z.unknown() is safer than z.any() as it requires explicit type checking before use
+export const SearchResultRecordDataSchema = z.object({
+	apiName: z.string(),
+	childRelationships: z.record(z.string(), z.unknown()),
+	eTag: z.string(),
+	fields: z.record(z.string(), z.unknown()), // Lightweight: avoids recursive validation, uses unknown for type safety
+	id: z.string(),
+	lastModifiedById: z.string().nullish(),
+	lastModifiedDate: z.string().nullish(),
+	recordTypeId: z.string().nullish(),
+	recordTypeInfo: z.unknown().nullish(),
+	systemModstamp: z.string().nullish(),
+	weakEtag: z.number(),
+});
+
+// Full validation schema for individual field values (use when validating specific fields)
+// This can be used to validate a single field value when needed
+export const FieldValueValidationSchema = FieldValueSchema;
+
+// Zod Schema for Highlight Info
+export const HighlightInfoSchema = z.object({
+	fields: z.record(z.string(), z.unknown()),
+	snippet: z.string().nullish(),
+});
+
+// Zod Schema for Search Info
+export const SearchInfoSchema = z.object({
+	isPromoted: z.boolean(),
+	isSpellCorrected: z.boolean(),
+});
+
+// Zod Schema for Search Result Record
+export const SearchResultRecordSchema = z.object({
+	highlightInfo: HighlightInfoSchema,
+	record: SearchResultRecordDataSchema,
+	searchInfo: SearchInfoSchema,
+});
+
+/**
+ * Record structure within search results
+ * Note: The fields property is typed as Record<string, FieldValue> for type safety,
+ * but validation uses z.unknown() for performance (avoids recursive validation of all fields)
+ */
+export type SearchResultRecordData = Omit<
+	z.infer<typeof SearchResultRecordDataSchema>,
+	"fields"
+> & {
+	fields: Record<string, FieldValue>;
+};
+
+/**
+ * Highlight information for search results
+ */
+export type HighlightInfo = z.infer<typeof HighlightInfoSchema>;
+
+/**
+ * Search information for results
+ */
+export type SearchInfo = z.infer<typeof SearchInfoSchema>;
+
+/**
+ * Single record in search results (complete structure from API)
+ * Note: The record.fields property is typed as Record<string, FieldValue> for type safety,
+ * but validation uses z.unknown() for performance (avoids recursive validation of all fields)
+ */
+export type SearchResultRecord = Omit<z.infer<typeof SearchResultRecordSchema>, "record"> & {
+	record: SearchResultRecordData;
+};
+
+// Export schemas for validation
+export const SearchResultRecordArraySchema = z.array(SearchResultRecordSchema);
+
+// Zod Schema for Order By
+export const OrderBySchema = z.object({
+	fieldApiName: z.string(),
+	isAscending: z.boolean(),
+	label: z.string(),
+});
+
+/**
+ * Order by configuration
+ */
+export type OrderBy = z.infer<typeof OrderBySchema>;
+
+// Zod Schema for Keyword Search Result
+export const KeywordSearchResultSchema = z.object({
+	currentPageToken: z.string(),
+	error: z.string().nullish(),
+	nextPageToken: z.string().nullish(),
+	objectApiName: z.string(),
+	orderBy: z.array(OrderBySchema),
+	pageSize: z.number(),
+	previousPageToken: z.string().nullish(),
+	records: z.array(SearchResultRecordSchema),
+	relatedObjectApiNames: z.array(z.string()),
+});
+
+/**
+ * Keyword search result structure
+ */
+export type KeywordSearchResult = z.infer<typeof KeywordSearchResultSchema>;
+
+// Zod Schema for Search Results Response
+export const SearchResultsResponseSchema = z.object({
+	configurationName: z.string().nullish(),
+	keywordSearchResult: KeywordSearchResultSchema,
+	objectApiName: z.string(),
+	query: z.string(),
+	queryId: z.string(),
+});
+
+/**
+ * Search results response structure
+ */
+export type SearchResultsResponse = z.infer<typeof SearchResultsResponseSchema>;
+
+// Zod Schema for Column Info Response
+export const ColumnInfoResponseSchema = z.record(z.string(), z.unknown()).and(
+	z.object({
+		columns: ColumnArraySchema.optional(),
+		fields: ColumnArraySchema.optional(),
+	}),
+);
+
+/**
+ * Column info response structure
+ */
+export type ColumnInfoResponse = z.infer<typeof ColumnInfoResponseSchema>;

package/dist/force-app/main/default/uiBundles/propertyrentalapp/src/utils/geocode.ts

@@ -0,0 +1,90 @@
+/**
+ * Geocode an address to lat/lng using OpenStreetMap Nominatim (free, no API key).
+ * Results are cached in memory (including 200 responses with empty results).
+ * Allows limited parallel in-flight requests (maxConcurrent).
+ */
+
+const CACHED_EMPTY = Symbol("cached empty geocode");
+type CacheEntry = { lat: number; lng: number } | typeof CACHED_EMPTY;
+
+const CACHE = new Map<string, CacheEntry>();
+const MAX_CONCURRENT = 6;
+let inFlight = 0;
+const queue: Array<() => void> = [];
+
+function acquire(): Promise<void> {
+	if (inFlight < MAX_CONCURRENT) {
+		inFlight += 1;
+		return Promise.resolve();
+	}
+	return new Promise<void>((resolve) => {
+		queue.push(() => {
+			inFlight += 1;
+			resolve();
+		});
+	});
+}
+
+function release(): void {
+	inFlight -= 1;
+	const next = queue.shift();
+	if (next) next();
+}
+
+export interface GeocodeResult {
+	lat: number;
+	lng: number;
+}
+
+/**
+ * Extracts "State Zip" from a US-style full address (e.g. "123 Main St, Unit 4B, Los Angeles, CA 90028" → "CA 90028").
+ * Used as a fallback when geocoding the full address fails.
+ */
+export function getStateZipFromAddress(address: string): string {
+	const parts = address
+		.split(",")
+		.map((p) => p.trim())
+		.filter(Boolean);
+	if (parts.length >= 1) {
+		return parts[parts.length - 1];
+	}
+	return address.trim();
+}
+
+export async function geocodeAddress(address: string): Promise<GeocodeResult | null> {
+	const key = address.trim().replace(/\s+/g, " ").toLowerCase();
+	if (!key) return null;
+	const cached = CACHE.get(key);
+	if (cached !== undefined) return cached === CACHED_EMPTY ? null : cached;
+
+	await acquire();
+	try {
+		const url = new URL("https://nominatim.openstreetmap.org/search");
+		url.searchParams.set("q", address.trim());
+		url.searchParams.set("format", "json");
+		url.searchParams.set("limit", "1");
+		const res = await fetch(url.toString(), {
+			headers: { "User-Agent": "PropertyListingApp/1.0 (contact@example.com)" },
+		});
+		if (!res.ok) return null;
+		const data = (await res.json()) as Array<{ lat?: string; lon?: string }>;
+		const first = data?.[0];
+		if (!first?.lat || !first?.lon) {
+			CACHE.set(key, CACHED_EMPTY);
+			return null;
+		}
+		const lat = Number(first.lat);
+		const lng = Number(first.lon);
+		if (Number.isNaN(lat) || Number.isNaN(lng)) {
+			CACHE.set(key, CACHED_EMPTY);
+			return null;
+		}
+		const result = { lat, lng };
+		CACHE.set(key, result);
+		return result;
+	} catch {
+		return null;
+	} finally {
+		release();
+	}
+}