@mailwoman/react 7.4.0 → 7.6.0

package/map/place-render.ts

@@ -0,0 +1,157 @@
+/**
+ * @copyright Sister Software
+ * @license AGPL-3.0
+ * @author Teffen Ellis, et al.
+ *
+ *   `computeMapPlaceRenderSpec` — the PURE core that replaces the docs demo's ~100-line imperative
+ *   marker/bbox/camera redraw effect (`_app.tsx:601-705`). It takes an ALREADY-RESOLVED place (the async
+ *   polygon-DB fetch is a host/runtime concern — a later phase — so a crisp polygon arrives pre-fetched
+ *   as `place.geometry`) and returns a declarative render spec: the marker position(s), the outline
+ *   geometry to draw, and the camera target. No map instance, no DOM, no `react-map-gl` — so it is
+ *   node-testable (see `place-render.node.test.ts`). The declarative components in this folder render
+ *   the spec; a controlled-viewport consumer applies the camera.
+ *
+ *   The decision cascade is a faithful, side-effect-free transcription of the imperative effect:
+ *     1. street tier (situs / interp)  → exact-radius circle, fly to a tight zoom
+ *     2. crisp admin polygon (pre-fetched) → draw the polygon, fit its bounds
+ *     3. anchor-centroid postcode (no bbox) → ~3 km "around here" circle, fly to zoom 11
+ *     4. bbox with real extent            → bbox-sized approximate circle, fit the bbox
+ *     5. bare point                       → no outline, fly to zoom 12
+ */
+
+import type { ResolvedPlaceView } from "../pipeline/types.ts"
+import { approxCircleGeometry, bboxToBounds, geomBounds, radiusCircleGeometry } from "./geometry.ts"
+import type { BoundsTuple, PlaceBBox, PlaceGeometry } from "./geometry.ts"
+
+/** `[longitude, latitude]`. */
+export type LngLat = [number, number]
+
+/** The street-level resolution tier (#377): `address_point` = exact building; `interpolated` = TIGER estimate. */
+export type PlaceTier = "address_point" | "interpolated"
+
+/**
+ * The resolved-place shape the map render consumes — the pipeline {@link ResolvedPlaceView} plus the map-only extras the
+ * demo's `ResolvedHit` carries (bbox, street tier + uncertainty), and an optional PRE-FETCHED crisp polygon. Extending
+ * `ResolvedPlaceView` keeps the map render aligned with the shared parse result; the extras are additive.
+ */
+export interface ResolvedMapPlace extends ResolvedPlaceView {
+	/** The place's bounding box, when the gazetteer carries one (admin places). Absent for anchor-centroid postcodes. */
+	bbox?: PlaceBBox
+	/** Street-level tier, when this hit came from the situs/interp tier rather than the WOF admin cascade. */
+	tier?: PlaceTier
+	/** Honest uncertainty radius in meters for a street-level tier (10 m situs floor; calibrated interp). */
+	uncertaintyM?: number
+	/**
+	 * The crisp admin polygon, when the host has ALREADY fetched it from the sibling polygon DB. Its presence drives the
+	 * polygon path; the async fetch itself stays out of this pure function (a runtime concern in a later phase).
+	 */
+	geometry?: PlaceGeometry
+}
+
+/**
+ * The camera target the render computes. `center` (fly to a point at a zoom) HAS a declarative equivalent — a consumer
+ * can feed it to a controlled `viewState` (see {@link cameraToViewState}). `bounds` (fit a box with pixel padding) does
+ * NOT — `fitBounds` needs the map's pixel dimensions, so it is applied imperatively by `<ResultCamera>`.
+ */
+export type MapCameraTarget =
+	| { kind: "center"; center: LngLat; zoom: number }
+	| { kind: "bounds"; bounds: BoundsTuple; padding: number }
+
+/** The declarative render spec for one resolved place — the pure output of {@link computeMapPlaceRenderSpec}. */
+export interface MapPlaceRenderSpec {
+	/** Marker position(s) as `[lon, lat]`. Single-element today; an array leaves room for multi-marker later. */
+	markers: LngLat[]
+	/** The outline geometry (polygon / circle) to draw, or `null` when the place renders as a bare point. */
+	outline: PlaceGeometry | null
+	/** The camera target — animate or fit to this. */
+	camera: MapCameraTarget
+}
+
+/** Zoom levels the imperative effect flew to, kept named so the cascade reads as intent, not magic numbers. */
+const ZOOM = {
+	addressPoint: 17,
+	interpolated: 15,
+	postcode: 11,
+	point: 12,
+} as const
+
+/** Padding (px) `fitBounds` insets a fitted box by, matching the ported effect. */
+const FIT_PADDING = 40
+
+/** The minimum lat/lon span (degrees) a bbox must exceed to be treated as a real extent rather than a point. */
+const MIN_EXTENT_DEG = 0.001
+
+/**
+ * Map a resolved place to its declarative render spec. Pure — same input, same output, no side effects. The `place`
+ * arrives fully resolved (crisp polygon pre-fetched into `place.geometry` when available), so this is the honest
+ * inverse of the old redraw effect with the imperative map mutation and the async DB load removed.
+ */
+export function computeMapPlaceRenderSpec(place: ResolvedMapPlace): MapPlaceRenderSpec {
+	const markers: LngLat[] = [[place.lon, place.lat]]
+
+	// 1. Street tier (#377): the honest uncertainty circle (exact meter radius) + a tight zoom. Takes precedence over
+	//    the admin polygon/bbox paths — a precise point gets no admin boundary.
+	if (place.tier && place.uncertaintyM != null) {
+		return {
+			markers,
+			outline: radiusCircleGeometry(place.lat, place.lon, place.uncertaintyM),
+			camera: {
+				kind: "center",
+				center: [place.lon, place.lat],
+				zoom: place.tier === "address_point" ? ZOOM.addressPoint : ZOOM.interpolated,
+			},
+		}
+	}
+
+	// 2. Crisp admin polygon (host pre-fetched it from the polygon DB) — draw the real boundary and fit it.
+	if (place.geometry) {
+		return {
+			markers,
+			outline: place.geometry,
+			camera: { kind: "bounds", bounds: bboxToBounds(geomBounds(place.geometry)), padding: FIT_PADDING },
+		}
+	}
+
+	// 3. Anchor-centroid postcode: no bbox, no polygon — a default ~3 km circle says "approximately here" without
+	//    inventing a boundary.
+	if (!place.bbox && place.placetype === "postcode") {
+		return {
+			markers,
+			outline: approxCircleGeometry(place.lat, place.lon),
+			camera: { kind: "center", center: [place.lon, place.lat], zoom: ZOOM.postcode },
+		}
+	}
+
+	// 4. A bbox with real extent — draw an approximate CIRCLE sized from the bbox (a rectangle would read as a wrong,
+	//    real boundary) and fit the bbox.
+	const bbox = place.bbox
+
+	if (bbox && Math.max(bbox.maxLat - bbox.minLat, bbox.maxLon - bbox.minLon) > MIN_EXTENT_DEG) {
+		return {
+			markers,
+			outline: approxCircleGeometry(place.lat, place.lon, bbox),
+			camera: { kind: "bounds", bounds: bboxToBounds(bbox), padding: FIT_PADDING },
+		}
+	}
+
+	// 5. A bare point (no tier, no polygon, no meaningful bbox) — just a marker and a mid zoom.
+	return {
+		markers,
+		outline: null,
+		camera: { kind: "center", center: [place.lon, place.lat], zoom: ZOOM.point },
+	}
+}
+
+/**
+ * The DECLARATIVE camera path: reshape a `center` target into a `viewState` patch a controlled `<DemoMap viewState>`
+ * can apply directly (a hard jump, no animation). Returns `null` for a `bounds` target — fitting a box to the viewport
+ * needs the map's pixel dimensions, which only the live map has, so that case is applied imperatively by
+ * `<ResultCamera>`. Pure + node-testable.
+ */
+export function cameraToViewState(
+	camera: MapCameraTarget
+): { longitude: number; latitude: number; zoom: number } | null {
+	if (camera.kind !== "center") return null
+
+	return { longitude: camera.center[0], latitude: camera.center[1], zoom: camera.zoom }
+}

package/map/types.ts

@@ -0,0 +1,207 @@
+/**
+ * @copyright Sister Software
+ * @license AGPL-3.0
+ * @author Teffen Ellis, et al.
+ *
+ *   Types for the geocoder-demo map surface. Mirrors the pipeline seam: the package owns the UI state
+ *   machine + the declarative map, while the host injects a {@link DemoRuntime} that owns ONNX / httpvfs
+ *   / R2 and the composed map style. {@link DemoRuntime} EXTENDS {@link PipelineRuntime} so the shared
+ *   `runParse` / `parseStageLabels` / `loading` contract is reused, and adds the map-specific surface
+ *   (style, overlays, initial center, viewport bias, backend/version selection). Phase 4 adds the
+ *   `resolveMapPlace` enricher, the {@link DemoPanels} injection bag, and the {@link DemoCompareContext}.
+ *
+ *   The map-spec types are imported type-only from `react-map-gl/maplibre`; nothing here loads maplibre at
+ *   runtime, so this module stays node-safe (its concrete-value CONSUMERS — `DemoMap`, `GeocoderDemo` —
+ *   are the ones gated behind the `@mailwoman/react/map` subpath).
+ */
+
+import type { ReactNode } from "react"
+import type { LayerSpecification, SourceSpecification } from "react-map-gl/maplibre"
+
+import type { ParseResult, PipelineRuntime, ResolvedPlaceView } from "../pipeline/types.ts"
+import type { DemoMapStyle } from "./DemoMap.tsx"
+import type { ResolvedMapPlace } from "./place-render.ts"
+
+/** `[longitude, latitude]`. */
+export type LngLatTuple = [number, number]
+
+/** A viewport bias handed to `runParse` — the map's current center (and optionally zoom) as a soft prior. */
+export interface MapBias {
+	/** Map center as `[lon, lat]`, typically read from `map.getCenter()`. */
+	center: LngLatTuple
+	/** Current zoom, if the host wants distance-aware biasing. */
+	zoom?: number
+}
+
+/**
+ * A host-supplied overlay: one map `<Source>` plus one or more `<Layer>`s laid over the basemap (coverage "fog of war",
+ * race-dots, …). The host composes the specs; the package renders them declaratively in a later phase.
+ */
+export interface OverlaySpec {
+	/** Stable id — used as the `<Source>` id and the layer-id prefix. */
+	id: string
+	/** The map source spec (vector/geojson/raster). */
+	source: SourceSpecification
+	/** The layers drawn from that source. */
+	layers: LayerSpecification[]
+	/** Whether the overlay is visible initially. @default true */
+	visible?: boolean
+	/** Human label for a layer-toggle control. */
+	label?: string
+}
+
+/** One autocomplete suggestion produced by the host's FST prefix-walk. */
+export interface Suggestion {
+	/** The text inserted when the suggestion is picked. */
+	value: string
+	/** Optional display label if it differs from `value`. */
+	label?: string
+	/** Optional place kind for badge/icon rendering. */
+	placetype?: string
+}
+
+/** A selectable model bundle (version tag + a display label the picker shows). */
+export interface DemoVersionOption {
+	/** The version tag (e.g. a git tag or model-card version). */
+	version: string
+	/** Display label; falls back to `version`. */
+	label?: string
+}
+
+/** Which neural backend the demo is currently running on. */
+export type DemoBackend = "webgpu" | "wasm"
+
+/**
+ * The injected demo runtime. Extends {@link PipelineRuntime} (shared `runParse` / `parseStageLabels` / `loading` /
+ * `ready`) with the map + version/backend surface the demo needs. The host composes `mapStyle` (via cartographer's
+ * `StyleSpecificationComposer` + the tile-worker TileJSON), supplies the overlay specs, the initial center (from
+ * geolocation), the FST autocomplete, and the calibrator — nothing in the package imports `@mailwoman/cartographer`,
+ * `@mailwoman/neural-web`, httpvfs, or Docusaurus.
+ */
+export interface DemoRuntime extends PipelineRuntime {
+	// ── Map ────────────────────────────────────────────────────────────────
+	/** The composed basemap style (URL or `StyleSpecification`). */
+	mapStyle: DemoMapStyle
+	/** Host-supplied overlays (coverage, race-dots, …). */
+	overlays?: OverlaySpec[]
+	/** Initial map center as `[lon, lat]` (the host's browser-geolocation result). */
+	initialCenter: LngLatTuple
+	/** Initial zoom for the first camera. */
+	initialZoom?: number
+
+	// ── Parse extras layered over PipelineRuntime.runParse ──────────────────
+	/**
+	 * A bias-aware parse. The map demo feeds the current viewport center as a soft prior; when absent the host falls back
+	 * to the base {@link PipelineRuntime.runParse}. Kept separate so the shared `runParse` contract is unchanged.
+	 */
+	runParseWithBias?: (
+		input: string,
+		bias: MapBias | null,
+		hooks: { onStage: (stage: number) => void }
+	) => ReturnType<PipelineRuntime["runParse"]>
+	/** FST prefix-walk autocomplete, wrapped by the host. */
+	autocomplete?: (query: string) => Promise<Suggestion[]>
+	/** Maps a raw model score to a calibrated one; `null` when no calibration table is loaded. */
+	calibrator?: (raw: number) => number | null
+	/**
+	 * Enrich the selected candidate into the richer {@link ResolvedMapPlace} the declarative map render consumes (bbox,
+	 * street tier + uncertainty, a pre-fetched crisp polygon) — the fields that live on the demo's `ResolvedHit` but not
+	 * on the shared {@link ResolvedPlaceView}. The host owns this because those extras (and the async polygon fetch in the
+	 * real demo) are host/gazetteer concerns; the package keeps {@link ParseResult} unpolluted. Absent → the candidate
+	 * renders as a bare point (marker + a mid-zoom fly-to). Returning `null` also renders nothing.
+	 */
+	resolveMapPlace?: (candidate: ResolvedPlaceView, result: ParseResult) => ResolvedMapPlace | null
+
+	// ── Version + backend selection ─────────────────────────────────────────
+	/** The selectable model bundles the version picker offers. */
+	availableVersions?: DemoVersionOption[]
+	/** The currently-selected model version. */
+	selectedVersion?: string
+	/** Switch the active model bundle (re-loads weights/tokenizer/gazetteer). */
+	selectVersion?: (version: string) => void
+	/** The backend the neural runtime resolved to (e.g. `webgpu (28 MB int8)`); free-form for the label. */
+	activeBackend?: string
+	/** Whether the CPU/WASM backend is currently forced (the controlled value for the backend toggle). */
+	forceWASM?: boolean
+	/** Force the WASM backend (opt out of WebGPU), for the backend toggle. */
+	setForceWASM?: (forceWASM: boolean) => void
+}
+
+/** The compare-mode state a {@link DemoPanels.compare} render-prop receives (the second parse itself stays host-side). */
+export interface DemoCompareContext {
+	/** The current primary parse result, or `null` before the first submit. */
+	result: ParseResult | null
+	/** Whether the compare toggle is on. */
+	compareMode: boolean
+	/** The version selected to compare against, or `null` when none is chosen. */
+	compareVersion: string | null
+}
+
+/**
+ * The state a {@link DemoPanels.result} render-prop receives, so a host can render its OWN result block (the docs
+ * `<ResultPanel>` with its span-highlight / timing / hierarchy / precision detail) in place of the package's default
+ * {@link ResultPanel}. Everything the default panel needs is passed through; the candidate-selection state stays owned
+ * by the package (`useDemoGeocode`).
+ */
+export interface DemoResultContext {
+	/** The current parse+resolve result. */
+	result: ParseResult
+	/** The selected candidate (falls back to the first), enriched for the resolved-place detail. */
+	selectedCandidate: ResolvedPlaceView | null
+	/** The selected candidate index, for the picker's active state. */
+	selectedCandidateIndex: number
+	/** Fired when a candidate in the picker is chosen. */
+	onSelectCandidate: (index: number) => void
+}
+
+/**
+ * Host-injected panels for {@link GeocoderDemo}, the map analogue of `PipelinePanels`. Each is an already-rendered
+ * `ReactNode` (or a thunk of the parse result / compare state) so the package needs neither the heavy docs visualizers
+ * (ModelVisualizer, VersionCompare, AboutDemo, PermalinkButton) nor their data types. Every field is optional — the
+ * fake-runtime Storybook stories pass none and still render the whole demo.
+ */
+export interface DemoPanels {
+	/** Rendered at the top of the control panel (e.g. the docs "About this demo"). */
+	header?: ReactNode
+	/** One-line release blurb for the selected version. */
+	releaseInfo?: ReactNode
+	/** Rendered at the bottom of the control panel (e.g. a guided tour). */
+	footer?: ReactNode
+	/**
+	 * A device-location / proximity-bias control, rendered between the query form and the autocomplete list (the demo's
+	 * "📍 Use my location" row). Host-owned so the geolocation permission + the bias it feeds into the host's
+	 * {@link DemoRuntime.runParseWithBias} stay a host concern.
+	 */
+	bias?: ReactNode
+	/** Heavy visualizers (span highlight, tree, timing, BIO, …), rendered from the result. */
+	extras?: (result: ParseResult) => ReactNode
+	/**
+	 * Rendered just above the result block (present or empty). The demo's opt-in display toggles live here — calibrated
+	 * confidence + dev-mode — because the host owns both the toggle state AND the {@link result} / {@link debugDrawer}
+	 * renderers those toggles drive.
+	 */
+	aboveResult?: (context: { result: ParseResult | null }) => ReactNode
+	/**
+	 * Replace the package's default {@link ResultPanel} entirely. When provided, the host renders its own result block
+	 * (the docs `<ResultPanel>` — span highlight, timing, hierarchy, precision detail, calibrated confidences) from the
+	 * {@link DemoResultContext}. Absent → the built-in panel renders.
+	 */
+	result?: (context: DemoResultContext) => ReactNode
+	/**
+	 * Rendered in place of the resolved-place panel when nothing resolved (host's FailureDiagnostic). Ignored when
+	 * {@link result} is set.
+	 */
+	failure?: (result: ParseResult) => ReactNode
+	/** The version-compare view — the host renders its own diff from the compare state it owns. */
+	compare?: (context: DemoCompareContext) => ReactNode
+	/**
+	 * The model-visualizer / debug drawer, mounted beside the map (host's ModelVisualizer). A render-prop so the host can
+	 * trace the CURRENT result (its input) — the package passes the live parse result; the host gates on its own dev-mode
+	 * state and returns `null` when the drawer is closed.
+	 */
+	debugDrawer?: (context: { result: ParseResult | null }) => ReactNode
+	/** Extra map controls mounted as `<DemoMap>` children (host's DebugControl / LayerToggle via `useControl`). */
+	mapControls?: ReactNode
+	/** A permalink control for the current address (host's PermalinkButton). */
+	permalink?: (text: string) => ReactNode
+}

package/map/useCompareState.ts

@@ -0,0 +1,45 @@
+/**
+ * @copyright Sister Software
+ * @license AGPL-3.0
+ * @author Teffen Ellis, et al.
+ *
+ *   `useCompareState` — the small headless state machine behind the demo's compare toggle
+ *   (`_app.tsx:142-143, 1238-1305`): whether compare mode is on, and which version to compare against.
+ *   Turning compare off clears the chosen version; selecting a compare version equal to the primary is
+ *   rejected (the picker filters it out, this guards the programmatic path). The SECOND parse itself is a
+ *   host concern surfaced through `panels.compare` — this hook owns only the toggle + selection.
+ */
+
+import { useCallback, useState } from "react"
+
+export interface UseCompareState {
+	/** Whether compare mode is on. */
+	compareMode: boolean
+	/** The version chosen to compare against, or `null`. */
+	compareVersion: string | null
+	/** Flip compare mode; turning it off clears the chosen version. */
+	setCompareMode: (compareMode: boolean) => void
+	/** Choose a compare version (`null` clears it). */
+	setCompareVersion: (version: string | null) => void
+	/** Keep the compare selection distinct from the primary — call when the primary version changes. */
+	clearIfPrimary: (primaryVersion: string) => void
+}
+
+export function useCompareState(): UseCompareState {
+	const [compareMode, setCompareModeState] = useState(false)
+	const [compareVersion, setCompareVersion] = useState<string | null>(null)
+
+	const setCompareMode = useCallback((next: boolean) => {
+		setCompareModeState(next)
+
+		if (!next) {
+			setCompareVersion(null)
+		}
+	}, [])
+
+	const clearIfPrimary = useCallback((primaryVersion: string) => {
+		setCompareVersion((prev) => (prev === primaryVersion ? null : prev))
+	}, [])
+
+	return { compareMode, compareVersion, setCompareMode, setCompareVersion, clearIfPrimary }
+}

package/map/useDemoGeocode.ts

@@ -0,0 +1,67 @@
+/**
+ * @copyright Sister Software
+ * @license AGPL-3.0
+ * @author Teffen Ellis, et al.
+ *
+ *   `useDemoGeocode` — the parse+resolve state machine for the geocoder map demo. It REUSES the pipeline's
+ *   `useParsePipeline` (text / busy / stage / result / candidate selection) and layers on the two map-only
+ *   concerns the demo adds over the base explorer:
+ *
+ *     1. Viewport bias — when the runtime exposes `runParseWithBias`, the current map center (read through
+ *        an injected `getBias`, itself reading the `MapRef`) rides along as a soft proximity prior. The
+ *        bias is injected by deriving a `runParse` that binds it, so `useParsePipeline` is reused verbatim.
+ *     2. The map render place — the selected candidate, enriched by the host's `resolveMapPlace` into the
+ *        richer {@link ResolvedMapPlace} the declarative overlays consume (bbox / tier / polygon). Absent
+ *        an enricher, the candidate renders as a bare point.
+ *
+ *   No maplibre import at module scope — the map handle is reached only through the injected `getBias`
+ *   callback, so this hook stays independent of the map binding.
+ */
+
+import { useMemo } from "react"
+
+import type { PipelineRuntime } from "../pipeline/types.ts"
+import { useParsePipeline, type UseParsePipeline } from "../pipeline/useParsePipeline.ts"
+import type { ResolvedMapPlace } from "./place-render.ts"
+import type { DemoRuntime, MapBias } from "./types.ts"
+
+export interface UseDemoGeocodeOptions {
+	/** The injected demo runtime (extends `PipelineRuntime` with the map + bias surface). */
+	runtime: DemoRuntime
+	/** Address to pre-fill. */
+	defaultText: string
+	/** Read the current viewport bias (the map center) at submit time. Absent → no bias. */
+	getBias?: () => MapBias | null
+}
+
+export interface UseDemoGeocode extends UseParsePipeline {
+	/** The selected candidate enriched into the map-render shape (bbox / tier / polygon), or `null`. */
+	mapPlace: ResolvedMapPlace | null
+}
+
+export function useDemoGeocode({ runtime, defaultText, getBias }: UseDemoGeocodeOptions): UseDemoGeocode {
+	// Bind the viewport bias into a derived `runParse` so `useParsePipeline` is reused unchanged. When the runtime has no
+	// bias-aware parse, pass it straight through.
+	const geoRuntime = useMemo<PipelineRuntime>(() => {
+		const withBias = runtime.runParseWithBias
+
+		if (!withBias) return runtime
+
+		return {
+			...runtime,
+			runParse: (input, hooks) => withBias(input, getBias?.() ?? null, hooks),
+		}
+	}, [runtime, getBias])
+
+	const pipeline = useParsePipeline({ runtime: geoRuntime, defaultText })
+
+	const mapPlace = useMemo<ResolvedMapPlace | null>(() => {
+		if (!pipeline.selectedCandidate || !pipeline.result) return null
+
+		return runtime.resolveMapPlace
+			? runtime.resolveMapPlace(pipeline.selectedCandidate, pipeline.result)
+			: pipeline.selectedCandidate
+	}, [pipeline.selectedCandidate, pipeline.result, runtime])
+
+	return { ...pipeline, mapPlace }
+}

package/map/useMapPlaceRender.ts

@@ -0,0 +1,21 @@
+/**
+ * @copyright Sister Software
+ * @license AGPL-3.0
+ * @author Teffen Ellis, et al.
+ *
+ *   `useMapPlaceRender` — the thin React memo wrapper over the pure {@link computeMapPlaceRenderSpec}. It
+ *   recomputes the render spec only when the resolved place changes, so the declarative overlays render a
+ *   stable spec object. The MATH lives in `place-render.ts` (pure, node-tested); this file adds nothing
+ *   but memoization, so it stays trivially correct. A `null` place (no result yet, or a result with no
+ *   candidate) yields `null` — the overlays render nothing.
+ */
+
+import { useMemo } from "react"
+
+import { computeMapPlaceRenderSpec } from "./place-render.ts"
+import type { MapPlaceRenderSpec, ResolvedMapPlace } from "./place-render.ts"
+
+/** Memoize the render spec for a resolved place; `null` in → `null` out (nothing to draw). */
+export function useMapPlaceRender(place: ResolvedMapPlace | null | undefined): MapPlaceRenderSpec | null {
+	return useMemo(() => (place ? computeMapPlaceRenderSpec(place) : null), [place])
+}