@expofp/floorplan 0.0.0-experimental.2d6c681

package/dist/esm/components/Map/drawing/config/config-load-layer.js

@@ -0,0 +1,119 @@
+import { BOOTHS_PAINTER_MARKER, SEPARATOR } from '../../../../constants';
+import { getFpPaths } from '../../../../data/fp-payloads';
+import { ensureVenueSceneLayerPayload } from '../../../../data/venue-scene-preload';
+import { createImageDef, createLayerDef } from '../../../../engine/defs';
+import store, { boothStore, uiState } from '../../../../store';
+import initBooths from '../../../../store/init/init-booths';
+import { getChildLayers } from '../../../../store/init/init-layers';
+import { LayersMode } from '../../../../store/LayerStore';
+import { chunkArray } from '../../../../utils';
+import { loadLayerImages } from '../../../../utils/loadLayerImages';
+import configBg, { BG_LAYER_NAME, FG_LAYER_NAME } from './config-bg';
+import configBooths, { BOOTHS_CHUNK_SIZE } from './config-booths';
+import { configOutdoorPoiLayer } from './config-outdoor-poi';
+import { registerLayerImages } from './layer-images';
+import { createModelDefFromElement } from './layer-models';
+import { getImageLayerName, getLayerGraphics, getModelLayerName } from './loadBoothsImages';
+function createChildLayers(layer) {
+    if (layer.childLayers.length)
+        return layer.childLayers;
+    return getChildLayers(layer, layer.basePriority, 15).layers;
+}
+async function configLayer(l, visible) {
+    const shown = visible && !store.layerStore.isLayerQuarantined(l);
+    const children = [];
+    const booths = initBooths(store, l);
+    // Outdoor PoI layers never enter the renderer scene — see
+    // configOutdoorPoiLayer. Booths are still initialized above so search,
+    // selection and hit-testing keep working.
+    if (configOutdoorPoiLayer(l, booths)) {
+        l.loaded = true;
+        l.configured = true;
+        l.children = [];
+        return createLayerDef(l.name, [], { hidden: true });
+    }
+    const layer = (await configBg(l));
+    const boothsLayers = [];
+    const boothChunks = chunkArray(booths, BOOTHS_CHUNK_SIZE);
+    const logosBooths = boothStore.booths.filter((b) => b.rect &&
+        (!b.layer || b.layer === l || b.layer.childLayers.includes(l)) &&
+        b.exhibitors.find((e) => !!e.logoInBooth && !!e.logo?.url) &&
+        !uiState.hideLogoInBooth);
+    const boothNoLabelsSnapshot = new Map(logosBooths.map((booth) => [booth, booth.noLabels]));
+    logosBooths.forEach((b) => (b.noLabels = true));
+    if (booths.length)
+        boothChunks.forEach((chunk, i) => {
+            boothsLayers.push(configBooths(`${l.name}${SEPARATOR}${BOOTHS_PAINTER_MARKER}${SEPARATOR}${i}`, chunk));
+        });
+    for (const [booth, noLabels] of boothNoLabelsSnapshot)
+        booth.noLabels = noLabels;
+    l.loaded = true;
+    const bg = layer.children.find((c) => c.name === BG_LAYER_NAME);
+    const fg = layer.children.find((c) => c.name === FG_LAYER_NAME);
+    const imageLayerName = getImageLayerName(l.name);
+    // Designer graphics split two ways: ordinary images, and the ones standing in for 3D models.
+    // A model element is never loaded as an image — its href is not fetched at all.
+    const { icons, models } = getLayerGraphics(l);
+    const imageLayer = { name: imageLayerName, children: [] };
+    const modelLayer = {
+        name: getModelLayerName(l.name),
+        children: models.map(createModelDefFromElement),
+    };
+    if (icons.length) {
+        registerLayerImages(imageLayerName, async () => {
+            const layerImages = await loadLayerImages(icons);
+            const children = [];
+            for (const { bounds, source } of layerImages)
+                children.push(createImageDef(source, bounds));
+            return { layer: imageLayer, children };
+        });
+    }
+    if (bg)
+        children.push({ ...bg, name: `${layer.name}${SEPARATOR}${BG_LAYER_NAME}` });
+    if (boothsLayers.length)
+        children.push(...boothsLayers);
+    if (fg)
+        children.push({ ...fg, name: `${layer.name}${SEPARATOR}${FG_LAYER_NAME}` });
+    if (icons.length)
+        children.push(imageLayer);
+    // Right after the images they replace, so a model sits exactly where its placeholder would have.
+    if (modelLayer.children.length)
+        children.push(modelLayer);
+    const childLayers = await Promise.all(l.childLayers
+        .sort((a, b) => a.basePriority - b.basePriority)
+        .map((childLayer) => configLayer(childLayer, true)));
+    children.push(...childLayers);
+    l.children = children;
+    l.configured = true;
+    return createLayerDef(l.name, children, { hidden: !shown });
+}
+export default async function loadLayer(layer) {
+    if (layer.configured)
+        return createLayerDef(layer.name, layer.children, { hidden: !layer.visible });
+    if (store.layerStore.mode !== LayersMode.Default &&
+        !getFpPaths(layer.name) &&
+        !layer.rootParent) {
+        // Resolve the layer's drawing ref through the venue-scene preloader: it
+        // shares an in-flight load with the bootstrap preload and confirms the
+        // payload actually landed (readers pull it back synchronously via
+        // getFpSvg/getFpPaths on the resolver's memo). A missing file used to
+        // load as a silent no-op script, so a failure only warns and the layer
+        // renders bare.
+        if (!(await ensureVenueSceneLayerPayload(layer.name))) {
+            console.warn(`Layer data not loaded: ${layer.name}`);
+        }
+    }
+    const childLayers = createChildLayers(layer);
+    if (childLayers.length) {
+        layer.childLayers = childLayers;
+        childLayers.forEach((childLayer) => {
+            store.layerStore.setLayerVisibility(childLayer, childLayer.visible);
+        });
+    }
+    const { layers } = store.layerStore;
+    store.layerStore.layers = [
+        ...layers,
+        ...childLayers.filter((childLayer) => !layers.some((layer) => layer.name === childLayer.name)),
+    ];
+    return configLayer(layer, layer.visible);
+}

package/dist/esm/components/Map/drawing/config/config-markers.d.ts

@@ -0,0 +1,42 @@
+import { type ImageDef, type RenderableDef, type SceneDef } from '@expofp/renderer';
+import { type FloorPlanMarkerEvent } from '../../../../types';
+export declare const MARKER_LAYER_NAME = "markers";
+/** What {@link configMarkers} needs: the scene whose root layers hold the marker layer. */
+export interface MarkerOptions {
+    /** The scene markers are drawn into; `config-all` pre-creates their layer in it. */
+    readonly scene: SceneDef;
+}
+/**
+ * Sizes one marker for a new pixel size — the `onScale` every marker def declares.
+ *
+ * One function for every marker on the plan, reached through each marker's own `onScale` closure
+ * and driven directly by the imperative bridge. Idempotent, because the center and rotation it
+ * reads back are the ones it wrote.
+ * @param marker - The marker to size.
+ * @param size - The icon's size in CSS pixels. Not the canvas's: that is rasterized at the device
+ *   ratio.
+ * @param pixelSize - Plan units per CSS pixel.
+ * @returns The def, which always moves — a marker holds its on-screen size at every zoom.
+ */
+export declare function rescaleMarker(marker: ImageDef, size: {
+    readonly width: number;
+    readonly height: number;
+}, pixelSize: number): readonly RenderableDef[];
+/**
+ * Draws the plan's markers into a renderer scene and keeps them current with the store.
+ * @param options - The scene to draw into.
+ * @returns A disposer.
+ */
+export declare function configMarkers(options: MarkerOptions): () => void;
+/**
+ * The marker a click on the plan landed on, at the size markers are currently drawn.
+ *
+ * The pixel size comes from the marker layer's own handler rather than from a renderer the plan holds
+ * a reference to — which is the whole of what this adds over {@link getMarkerFromClick}.
+ * @param x - Where the click landed, in plan units.
+ * @param y - Where the click landed, in plan units.
+ * @returns The marker, or `null` when the click reached none.
+ */
+export declare function markerAt(x: number, y: number): FloorPlanMarkerEvent | null;
+export declare function getMarkerFromClick(x: number, y: number, scale: number): import("../../../../store/RouteStore").Marker | null;
+//# sourceMappingURL=config-markers.d.ts.map

package/dist/esm/components/Map/drawing/config/config-markers.js

@@ -0,0 +1,278 @@
+import { Box } from '@expofp/geometry';
+import { update, } from '@expofp/renderer';
+import { reaction } from 'mobx';
+import { createImageDef } from '../../../../engine/defs';
+import store, { layersStore, uiState } from '../../../../store';
+import { setMarkerResolver } from '../../pointer';
+import { createImageCanvas, getBounds, imageCanvasCssSize } from './canvases';
+const SELECTED_ID = '_selected';
+export const MARKER_LAYER_NAME = 'markers';
+/**
+ * Sizes one marker for a new pixel size — the `onScale` every marker def declares.
+ *
+ * One function for every marker on the plan, reached through each marker's own `onScale` closure
+ * and driven directly by the imperative bridge. Idempotent, because the center and rotation it
+ * reads back are the ones it wrote.
+ * @param marker - The marker to size.
+ * @param size - The icon's size in CSS pixels. Not the canvas's: that is rasterized at the device
+ *   ratio.
+ * @param pixelSize - Plan units per CSS pixel.
+ * @returns The def, which always moves — a marker holds its on-screen size at every zoom.
+ */
+export function rescaleMarker(marker, size, pixelSize) {
+    const { center, rotation, elevation } = marker.bounds;
+    const { width, height } = size;
+    // Elevation rides along with the center and the rotation. This builds a fresh Rect rather than
+    // resizing in place, so anything it does not read back is dropped, and a marker raised off the
+    // floor would sink to it on the first zoom step.
+    marker.bounds = getBounds(center.x, center.y, width, height, pixelSize, rotation, elevation);
+    return [marker];
+}
+/**
+ * Records the pixel size markers are drawn at — the marker layer's own `onScale`.
+ *
+ * Lays nothing out and returns nothing, so it never costs a write. It is here because {@link markerAt}
+ * has to size a marker's hit box the way the marker itself was sized, and the pixel size is knowledge
+ * only the renderer has.
+ * @param _def - The marker layer, unused.
+ * @param pixelSize - Plan units per CSS pixel.
+ */
+function readMarkerPixelSize(pixelSize) {
+    markerPixelSize = pixelSize;
+}
+/**
+ * Draws the plan's markers into a renderer scene and keeps them current with the store.
+ * @param options - The scene to draw into.
+ * @returns A disposer.
+ */
+export function configMarkers(options) {
+    const { scene } = options;
+    const disposers = [];
+    const iconMap = new Map();
+    const canvasCache = new Map();
+    let markerDefs = [];
+    const markerLayer = scene.rootLayer.children.find((i) => i.name === MARKER_LAYER_NAME);
+    // Markers are not picked — a click resolves to one through `markerAt`, as it always has — so the
+    // layer declares no pointer handler and never joins the raycast set. What it does declare is where
+    // the hit test gets the pixel size it needs, which only the renderer knows.
+    markerLayer.onScale = ({ pixelSize }) => readMarkerPixelSize(pixelSize);
+    setMarkerResolver(markerAt);
+    update(markerLayer);
+    async function loadMarkerIcons(icons) {
+        const promises = [];
+        icons.forEach((icon) => {
+            const { name, content, width, height, scale } = icon;
+            if (iconMap.has(name))
+                return;
+            const img = new Image();
+            const promise = new Promise((resolve, reject) => {
+                img.onload = () => {
+                    iconMap.set(name, { img, width, height, scale });
+                    resolve();
+                };
+                img.onerror = (error) => {
+                    reject(error);
+                };
+            });
+            promises.push(promise);
+            img.src = content;
+            img.crossOrigin = 'anonymous';
+        });
+        await Promise.all(promises);
+    }
+    // The rules ride on the defs: the renderer lays a def out as it registers and again on every
+    // zoom step or roll change, in either mount.
+    const bindScale = (def, size) => {
+        def.onScale = ({ pixelSize }) => rescaleMarker(def, size, pixelSize);
+    };
+    const bindRoll = (def) => {
+        // A screen-space marker stands up to face the viewer, and `bounds.rotation` on it is a spin about
+        // the screen's normal, not a plan bearing. A roll rule would still run on it and spin the marker
+        // away from upright, so none is declared.
+        if (def.screenSpace)
+            return;
+        // A marker turns with the plan to the absolute angle, unlike the quarter-turn steppers, so an
+        // unchanged roll is the only no-op. `rotate` adds a delta, so subtract current.
+        def.onRoll = ({ roll }) => {
+            if (roll === def.bounds.rotation)
+                return undefined;
+            def.bounds.rotate(roll - def.bounds.rotation, def.bounds);
+            return [def];
+        };
+    };
+    /**
+     * One icon's canvas, drawn once and kept for every marker that asks for it again.
+     *
+     * Reads and fills in one step, so the value it hands back is the one it just stored. A separate
+     * `has` and `get` leaves the caller holding a value the types have to call optional.
+     * @param key - The icon's own name, which is what the cache is keyed by.
+     * @param icon - The icon to draw.
+     * @returns The canvas.
+     */
+    function cachedCanvas(key, icon) {
+        const cached = canvasCache.get(key);
+        if (cached)
+            return cached;
+        // Rasterized at the device ratio for crispness, at the icon's own scale for the size.
+        const canvas = createImageCanvas(icon.img, icon.width, icon.height, window.devicePixelRatio, icon.scale || 1);
+        canvasCache.set(key, canvas);
+        return canvas;
+    }
+    function drawMarkers() {
+        const markers = store.routeStore.markersData.markers;
+        if (!markers.length)
+            return;
+        markerDefs = [];
+        // Placeholders: a def is laid out as it registers, and `rescaleMarker`/`onRoll` rebuild the
+        // bounds from the center the moment the renderer reports the real pixel size and roll.
+        const ptscale = 1;
+        const rollRadians = 0;
+        // On a 3D plan a marker lying on the floor smears under tilt, so it stands up to face the
+        // viewer instead. `is3DView` is the venue's own flag and does not change while a plan is open.
+        // The marker layer goes into the overlay tier for the same reason, in `config-all`.
+        const screenSpace = uiState.is3DView;
+        markers.forEach((marker) => {
+            const icon = iconMap.get(marker.icon);
+            if (!icon)
+                return;
+            // Skipped the way a missing icon is. A marker draws both states, so one without its selected
+            // icon has no second def to build and would take the whole sweep down on the first read.
+            const selectedIcon = iconMap.get(marker.selectedIcon);
+            if (!selectedIcon)
+                return;
+            const iconScale = icon.scale || 1;
+            const markerCanvas = cachedCanvas(marker.icon, icon);
+            const selectedMarkerCanvas = cachedCanvas(marker.selectedIcon, selectedIcon);
+            const visible = layersStore.findLayer(marker.z)?.visible ?? true;
+            // The size the icon is drawn at, which the canvas's backing store says nothing of: that is in
+            // the device pixels the icon was rasterized at, for crispness.
+            const cssSize = imageCanvasCssSize(icon.img, icon.width, icon.height, iconScale);
+            const selectedCssSize = imageCanvasCssSize(selectedIcon.img, selectedIcon.width, selectedIcon.height, iconScale);
+            const markerBounds = getBounds(marker.x, marker.y, cssSize.width, cssSize.height, ptscale, rollRadians);
+            const selectedMarkerBounds = getBounds(marker.x, marker.y, selectedCssSize.width, selectedCssSize.height, ptscale, rollRadians);
+            let origin;
+            switch (marker.position) {
+                case 'lefttop':
+                    origin = [0, 0];
+                    break;
+                case 'centertop':
+                    origin = [0.5, 0];
+                    break;
+                case 'centerbottom':
+                    origin = [0.5, 1];
+                    break;
+                default:
+                    origin = [0.5, 0.5];
+            }
+            const imageDef = createImageDef(markerCanvas, markerBounds, { hidden: !visible, origin });
+            const markerDef = { ...imageDef, id: marker.id, scale: iconScale, screenSpace };
+            const selectedImageDef = createImageDef(selectedMarkerCanvas, selectedMarkerBounds, {
+                hidden: !(visible && marker.active),
+                origin,
+            });
+            const selectedMarkerDef = {
+                ...selectedImageDef,
+                id: `${marker.id}${SELECTED_ID}`,
+                scale: iconScale,
+                screenSpace,
+            };
+            bindScale(markerDef, cssSize);
+            bindScale(selectedMarkerDef, selectedCssSize);
+            markerDefs.push(markerDef, selectedMarkerDef);
+        });
+        markerLayer.children = markerDefs;
+        markerDefs.forEach(bindRoll);
+    }
+    function clearMarkers() {
+        markerLayer.children = [];
+        markerDefs = [];
+    }
+    function updateMarkers() {
+        const markers = store.routeStore.markersData.markers;
+        if (!markers.length)
+            return;
+        markers.forEach((marker) => {
+            const markerDef = markerDefs.find((def) => def.id === marker.id);
+            const markerSelectedDef = markerDefs.find((def) => def.id === `${marker.id}${SELECTED_ID}`);
+            // A marker is pushed with its selected def or not at all, so either one missing means this
+            // marker was never drawn and there is nothing here to update.
+            if (!markerDef || !markerSelectedDef)
+                return;
+            const visible = layersStore.findLayer(marker.z)?.visible ?? true;
+            if (marker.active) {
+                markerDef.hidden = true;
+                markerSelectedDef.hidden = !(visible && marker.active);
+            }
+            else {
+                markerDef.hidden = !visible;
+                markerSelectedDef.hidden = true;
+            }
+        });
+    }
+    disposers.push(reaction(() => [store.routeStore.selectedMarkers, store.layerStore.visible], () => {
+        const markers = store.routeStore.markersData.markers;
+        if (!markers.length) {
+            clearMarkers();
+            update(markerLayer);
+            return;
+        }
+        updateMarkers();
+        update(...markerDefs);
+    }));
+    disposers.push(reaction(() => store.routeStore.markersData.markers, () => {
+        loadMarkerIcons(store.routeStore.markersData.icons).then(() => {
+            drawMarkers();
+            update(markerLayer);
+        });
+    }, { fireImmediately: true }));
+    return function cleanup() {
+        disposers.forEach((d) => d());
+        disposers.length = 0;
+        markerLayer.onScale = undefined;
+        setMarkerResolver();
+        // back to the pre-layout seed, so the next plan's first clicks are hit-tested
+        // at its own marker size rather than at this one's
+        markerPixelSize = 1;
+        update(markerLayer);
+    };
+}
+/**
+ * The marker a click on the plan landed on, at the size markers are currently drawn.
+ *
+ * The pixel size comes from the marker layer's own handler rather than from a renderer the plan holds
+ * a reference to — which is the whole of what this adds over {@link getMarkerFromClick}.
+ * @param x - Where the click landed, in plan units.
+ * @param y - Where the click landed, in plan units.
+ * @returns The marker, or `null` when the click reached none.
+ */
+export function markerAt(x, y) {
+    return getMarkerFromClick(x, y, markerPixelSize);
+}
+export function getMarkerFromClick(x, y, scale) {
+    for (const marker of store.routeStore.markersData.markers) {
+        const icon = store.routeStore.markersData.icons.find((icon) => icon.name === marker.icon);
+        if (!icon)
+            continue;
+        const iconWidth = icon.width * (icon.scale || 1) * scale;
+        const iconHeight = icon.height * (icon.scale || 1) * scale;
+        if (isPointInMarker(x, y, marker.x, marker.y, iconWidth, iconHeight)) {
+            const layer = store.layerStore.findLayer(marker.z);
+            if (!layer || (layer && layer.visible)) {
+                return marker;
+            }
+        }
+    }
+    return null;
+}
+function isPointInMarker(x, y, markerX, markerY, iconWidth, iconHeight) {
+    // iconWidth/iconHeight are half-extents, so the hit box spans 2× each from
+    // the marker center.
+    const hitBox = Box.fromCenter({ x: markerX, y: markerY }, { x: 2 * iconWidth, y: 2 * iconHeight });
+    return hitBox.containsPoint({ x, y });
+}
+/**
+ * The pixel size markers were last drawn at, kept current by {@link readMarkerPixelSize}. Seeded at
+ * `1` for the window between the scene being built and its first layout, when nothing is drawn yet
+ * and so nothing can be clicked either.
+ */
+let markerPixelSize = 1;

package/dist/esm/components/Map/drawing/config/config-outdoor-poi.d.ts

@@ -0,0 +1,19 @@
+import { type Booth } from '../../../../store/BoothStore';
+import { type Layer } from '../../../../store/LayerStore';
+/**
+ * Handles the Outdoor PoI markers (hotels, parking, transit) for one designer
+ * layer. Outdoor layers contain nothing but PoI pins — points without a
+ * physical size — so the layer contributes nothing to the renderer scene. In
+ * the geo map every PoI booth becomes a fixed-size native MapLibre marker
+ * (usePoiMarkers); in floorplan-only and legacy-SVG modes nothing renders.
+ * Clicks, selection and routing are unaffected — booths are hit-tested by
+ * geometry (getBoothIdFromClientXy), not by the rendered shape. Rationale:
+ * docs/adr/0011-declaring-a-place-outdoors-makes-it-a-journey-place.md.
+ *
+ * Returns true when the layer is an Outdoor layer; the caller must then
+ * exclude it from the scene. False leaves regular layers exactly as-is —
+ * including with `enableExperimentalOutdoorMarkers` off, so Outdoor layers then
+ * draw the way they did before the feature existed.
+ */
+export declare function configOutdoorPoiLayer(l: Layer, booths: readonly Booth[]): boolean;
+//# sourceMappingURL=config-outdoor-poi.d.ts.map

package/dist/esm/components/Map/drawing/config/config-outdoor-poi.js

@@ -0,0 +1,96 @@
+import Color from 'color';
+import { POI_MARKER_PIN_WIDTH_PX, POI_PIN_DEFAULT_COLOR } from '../../../../constants';
+import store, { uiState } from '../../../../store';
+import { loadImage } from '../../../../utils/loadImage';
+import { isOutdoorMarkersEnabled, isOutdoorPoiLayer } from '../../../../utils/outdoor-poi';
+import { createPoiPinImage } from './poi-pin.js';
+const isPaintableColor = (c) => !!c && c !== 'transparent' && c !== 'none';
+// The pin fill for a PoI booth: the color authored in the Designer, preferring
+// the path color and falling back to the resolved shape fill. Returns null when
+// nothing was authored, leaving the caller its default. Mirrors monochrome mode.
+function getPoiPinColor(booth) {
+    const fromPaths = (booth.paths ?? []).map((p) => p.color).find(isPaintableColor);
+    const fromShapes = (booth.shapes ?? [])
+        .map((s) => s.color)
+        .find(isPaintableColor);
+    const color = fromPaths ?? fromShapes ?? null;
+    if (!color)
+        return null;
+    try {
+        return uiState.monochrome ? Color(color).grayscale().rgb().string() : color;
+    }
+    catch {
+        return color;
+    }
+}
+/**
+ * Rasterizes the pins for one Outdoor layer's PoI booths and publishes them to
+ * the PoiMarkerStore. Purely async and self-contained: the markers are not part
+ * of the renderer scene, so this doesn't block or contribute to layer
+ * configuration. Icon loads that outlive a scene teardown/rebuild are dropped
+ * via the store's generation guard.
+ */
+async function buildPoiMarkers(poiBooths) {
+    const generation = store.poiMarkerStore.generation;
+    const pixelRatio = window.devicePixelRatio || 1;
+    const newMarkers = [];
+    const poiTypeById = new Map((store.poiTypeStore?.poiTypes ?? []).map((p) => [p.id, p]));
+    // Icons are per poiType, not per booth: every "Parking" pin draws the same
+    // glyph. Share the load so a hundred booths don't fetch and decode it a
+    // hundred times.
+    const iconByUrl = new Map();
+    const loadIcon = (url) => {
+        let pending = iconByUrl.get(url);
+        if (!pending) {
+            pending = loadImage(url);
+            iconByUrl.set(url, pending);
+        }
+        return pending;
+    };
+    await Promise.all(poiBooths.map(async (booth) => {
+        const iconUrl = booth.poiTypeId == null ? undefined : poiTypeById.get(booth.poiTypeId)?.iconUrl;
+        // A missing icon (no iconUrl, failed load) never drops the marker: the
+        // pin is the booth's only visual — it just renders without the glyph.
+        const image = iconUrl ? await loadIcon(iconUrl) : null;
+        if (iconUrl && !image) {
+            console.warn('PoI icon failed to load', booth.name, iconUrl);
+        }
+        const center = booth.rect.center;
+        newMarkers.push({
+            boothId: booth.id,
+            center: { x: center.x, y: center.y },
+            icon: createPoiPinImage(image, POI_MARKER_PIN_WIDTH_PX, pixelRatio, getPoiPinColor(booth) ?? POI_PIN_DEFAULT_COLOR),
+        });
+    }));
+    // Torn down/rebuilt while loading: these canvases belong to a dead scene.
+    if (store.poiMarkerStore.generation !== generation)
+        return;
+    // Publish to the store (one notification for the whole batch);
+    // usePoiMarkers picks them up and (re)builds the MapLibre marker source.
+    store.poiMarkerStore.addMany(newMarkers);
+}
+/**
+ * Handles the Outdoor PoI markers (hotels, parking, transit) for one designer
+ * layer. Outdoor layers contain nothing but PoI pins — points without a
+ * physical size — so the layer contributes nothing to the renderer scene. In
+ * the geo map every PoI booth becomes a fixed-size native MapLibre marker
+ * (usePoiMarkers); in floorplan-only and legacy-SVG modes nothing renders.
+ * Clicks, selection and routing are unaffected — booths are hit-tested by
+ * geometry (getBoothIdFromClientXy), not by the rendered shape. Rationale:
+ * docs/adr/0011-declaring-a-place-outdoors-makes-it-a-journey-place.md.
+ *
+ * Returns true when the layer is an Outdoor layer; the caller must then
+ * exclude it from the scene. False leaves regular layers exactly as-is —
+ * including with `enableExperimentalOutdoorMarkers` off, so Outdoor layers then
+ * draw the way they did before the feature existed.
+ */
+export function configOutdoorPoiLayer(l, booths) {
+    if (!isOutdoorMarkersEnabled())
+        return false;
+    if (!isOutdoorPoiLayer(l))
+        return false;
+    if (store.maplibreStore.showMaplibre) {
+        void buildPoiMarkers(booths.filter((b) => b.poiTypeId && b.rect));
+    }
+    return true;
+}

package/dist/esm/components/Map/drawing/config/config-pins.d.ts

@@ -0,0 +1,40 @@
+import { type LayerDef } from '@expofp/renderer';
+/**
+ * Draws a pin over every booth an active POI-type search button selects, and draws the renderer's
+ * clusters of those pins from a pool of hidden markers.
+ *
+ * The pins key off `uiState.selectedPoiTypeFilters`, which is what both a single `poi_type` button
+ * and a `poi_types` group button write — so one filter or a whole group reaches this the same way.
+ *
+ * This module only *substitutes*. The renderer decides which pins collide, hides every pin in a
+ * cluster through its own `onPlace`, and reports the clusters to the pin layer's `clustering`. What
+ * this draws for a report is a pooled marker per cluster, in two sibling layers that declare neither
+ * `placement` nor `clustering`, so a marker can never be clustered as its own input.
+ *
+ * Nothing is created or destroyed on a camera move. The pins are built when the booth set changes,
+ * one per booth, and so is the pool: a cluster needs two pins, so `floor(n / 2)` markers is every
+ * marker a report can ask for. A report writes positions and counts onto defs already mounted, and
+ * no layer's `children` is reassigned by anything but a booth-set change.
+ *
+ * Takes the layers rather than the scene, so it runs in `config-all` beside the layers' creation:
+ * nothing here needs the renderer, and `update` before the scene mounts is a documented no-op that
+ * the mount's own full sync covers.
+ * @param pinLayer - The layer for pins, which `config-all` creates.
+ * @param clusterLayer - The layer for cluster teardrops, created directly above `pinLayer`.
+ * @param countLayer - The layer for cluster counts, created directly above `clusterLayer`.
+ * @returns A disposer.
+ */
+export declare function configPins(pinLayer: LayerDef, clusterLayer: LayerDef, countLayer: LayerDef): () => void;
+/** The layer `config-all` pre-creates for pins, and the one whose clustering this module declares. */
+export declare const PIN_LAYER_NAME = "poiFilterPins";
+/** The layer `config-all` pre-creates for cluster teardrops, drawn directly above the pins. */
+export declare const PIN_CLUSTER_LAYER_NAME = "poiFilterPinClusters";
+/** The layer `config-all` pre-creates for cluster counts, drawn directly above the teardrops. */
+export declare const PIN_COUNT_LAYER_NAME = "poiFilterPinCounts";
+/**
+ * How long a pin takes to fade in or out, in milliseconds. MapLibre's `fadeDuration` default, which
+ * the placement spec's research cites: long enough that a crowd thinning out reads as motion, short
+ * enough that a zoom does not leave half-faded pins behind the camera.
+ */
+export declare const PIN_FADE_MS = 300;
+//# sourceMappingURL=config-pins.d.ts.map