@expofp/floorplan 0.0.0-experimental.2632d13

package/dist/esm/components/Map/pointer.d.ts

@@ -0,0 +1,79 @@
+import { type PointerEventData, type PointerMissedEventData, type ShapeDef } from '@expofp/renderer';
+import { type Booth } from '../../store/BoothStore';
+import { type FloorPlanMarkerEvent } from '../../types';
+/** How a click on the plan resolves to a marker. See {@link setMarkerResolver}. */
+export type MarkerResolver = (x: number, y: number) => FloorPlanMarkerEvent | null;
+/**
+ * Registers a listener for every click that lands on the plan, hit or miss, before selection acts
+ * on it — the seam the kiosk setup screen and the route-authoring tool take their clicks from,
+ * which the imperative renderer served with its own `pointer:click` listeners.
+ *
+ * One listener at a time: the two consumers are modal and never active together.
+ * @param listener - Receives the plan point; omitted to unregister.
+ */
+export declare function setPlanClickListener(listener?: (point: {
+    x: number;
+    y: number;
+}) => void): void;
+/**
+ * Registers how a click resolves to a marker, for as long as markers are drawn.
+ *
+ * The same inversion {@link rememberBoothShapes} performs for booths, and for the same reason: this
+ * seam is reached from a click and must stay free of the modules that build defs — the marker hit
+ * test needs both the marker data and the pixel size their own layer is laid out at.
+ * @param resolve - Returns the marker under a plan point, or `null`; omitted to unregister.
+ */
+export declare function setMarkerResolver(resolve?: MarkerResolver): void;
+/**
+ * Records which booth a set of background shapes belongs to, so a pointer hit can name it.
+ *
+ * A booth draws as one rect, or as several polygons when it comes from paths, and the renderer
+ * reports whichever def was hit. Registered where the defs are built rather than searched for later:
+ * the alternative is scanning every booth's shapes on every pointer move.
+ * @param booth - The booth the shapes draw.
+ * @param shapes - Its background shapes.
+ */
+export declare function rememberBoothShapes(booth: Booth, shapes: readonly ShapeDef[]): void;
+/**
+ * The booth a hit def draws, if any.
+ * @param def - The def the renderer reported.
+ * @returns The booth, or `null` for a def that is not a booth background.
+ */
+export declare function boothOfShape(def: ShapeDef): Booth | null;
+/**
+ * Tracks the booth under the pointer. Declared on the booth background layer, which is the only
+ * layer the plan picks in.
+ *
+ * The renderer delivers every booth along the ray, nearest first, so this takes the first and stops
+ * the rest. Without the stop, the farthest booth would win. The stop comes before the write because
+ * stopping un-hovers the farther booths, and their `onPointerOut` clears the field.
+ * @param event - The def under the pointer.
+ */
+export declare function hoverBooth(event: PointerEventData<ShapeDef>): void;
+/**
+ * Clears the hovered booth as the pointer leaves it.
+ */
+export declare function clearHoveredBooth(): void;
+/**
+ * Selects the booth that was clicked.
+ * @param event - The def that was clicked, and where on the plan.
+ */
+export declare function selectBooth(event: PointerEventData<ShapeDef>): void;
+/**
+ * Handles a click that reached no booth — empty background, or a def in a layer the plan does not
+ * pick in — which deselects, exactly as clicking away from a booth always has.
+ * @param event - Where on the plan the click landed.
+ */
+export declare function clearSelection(event: PointerMissedEventData): void;
+/**
+ * Calls the kiosk's idle-reset hook, if one is installed. A global (`window.__resett`), which is how
+ * the parts of the SDK that are not components reach the timer `init-ui` owns — and which an
+ * embedding page may install instead.
+ *
+ * Exported because the user moving the camera counts as activity too, not only a click: `MapCamera`
+ * calls it while the visitor has hold of the plan, as the imperative renderer's `navigation:change`
+ * listener did. A command is left out on purpose — the idle reset moves the camera itself, and would
+ * re-arm the timer it had just fired.
+ */
+export declare function resetExternalOverlay(): void;
+//# sourceMappingURL=pointer.d.ts.map

package/dist/esm/components/Map/pointer.js

@@ -0,0 +1,181 @@
+import store, { uiState } from '../../store';
+import { LayerMode } from '../../store/LayerStore';
+import { poiMarkerHitTest } from '../Maplibre/utils/poi-marker-hit-test';
+import { venueTapHitTest } from '../Maplibre/utils/venue-tap-hit-test';
+import getBoothIdFromClientXy from './booth-by-xy';
+/**
+ * Registers a listener for every click that lands on the plan, hit or miss, before selection acts
+ * on it — the seam the kiosk setup screen and the route-authoring tool take their clicks from,
+ * which the imperative renderer served with its own `pointer:click` listeners.
+ *
+ * One listener at a time: the two consumers are modal and never active together.
+ * @param listener - Receives the plan point; omitted to unregister.
+ */
+export function setPlanClickListener(listener) {
+    planClickListener = listener;
+}
+/**
+ * Registers how a click resolves to a marker, for as long as markers are drawn.
+ *
+ * The same inversion {@link rememberBoothShapes} performs for booths, and for the same reason: this
+ * seam is reached from a click and must stay free of the modules that build defs — the marker hit
+ * test needs both the marker data and the pixel size their own layer is laid out at.
+ * @param resolve - Returns the marker under a plan point, or `null`; omitted to unregister.
+ */
+export function setMarkerResolver(resolve) {
+    markerResolver = resolve;
+}
+/**
+ * Records which booth a set of background shapes belongs to, so a pointer hit can name it.
+ *
+ * A booth draws as one rect, or as several polygons when it comes from paths, and the renderer
+ * reports whichever def was hit. Registered where the defs are built rather than searched for later:
+ * the alternative is scanning every booth's shapes on every pointer move.
+ * @param booth - The booth the shapes draw.
+ * @param shapes - Its background shapes.
+ */
+export function rememberBoothShapes(booth, shapes) {
+    for (const shape of shapes)
+        mapShapeToBooth.set(shape, booth);
+}
+/**
+ * The booth a hit def draws, if any.
+ * @param def - The def the renderer reported.
+ * @returns The booth, or `null` for a def that is not a booth background.
+ */
+export function boothOfShape(def) {
+    return mapShapeToBooth.get(def) ?? null;
+}
+/**
+ * Tracks the booth under the pointer. Declared on the booth background layer, which is the only
+ * layer the plan picks in.
+ *
+ * The renderer delivers every booth along the ray, nearest first, so this takes the first and stops
+ * the rest. Without the stop, the farthest booth would win. The stop comes before the write because
+ * stopping un-hovers the farther booths, and their `onPointerOut` clears the field.
+ * @param event - The def under the pointer.
+ */
+export function hoverBooth(event) {
+    if (uiState.setKioskModeEnabled)
+        return;
+    event.stopPropagation();
+    uiState.hoveredBooth = boothAt(event.point, event.def);
+}
+/**
+ * Clears the hovered booth as the pointer leaves it.
+ */
+export function clearHoveredBooth() {
+    if (uiState.setKioskModeEnabled)
+        return;
+    uiState.hoveredBooth = null;
+}
+/**
+ * Selects the booth that was clicked.
+ * @param event - The def that was clicked, and where on the plan.
+ */
+export function selectBooth(event) {
+    // The nearest booth only, as for hover.
+    event.stopPropagation();
+    if (!clickedPlan(event.point, event.nativeEvent))
+        return;
+    store.clickBooth(boothAt(event.point, event.def));
+}
+/**
+ * Handles a click that reached no booth — empty background, or a def in a layer the plan does not
+ * pick in — which deselects, exactly as clicking away from a booth always has.
+ * @param event - Where on the plan the click landed.
+ */
+export function clearSelection(event) {
+    if (!clickedPlan(event.point, event.nativeEvent))
+        return;
+    // A miss can still be a booth: outdoor-POI booths deliberately have no defs in the scene and are
+    // hit-tested by geometry alone, exactly as every click resolved them before def picking existed.
+    store.clickBooth(boothAt(event.point));
+}
+/**
+ * The booth at a plan point: the def the renderer reported first — a WeakMap lookup — and only
+ * when that names no booth the geometry scan over every booth's shapes, which is the one test
+ * outdoor-POI booths have, since their layers never enter the scene. The scan is what makes a
+ * miss still resolvable; the def is what keeps the common case — hover sweeping across drawn
+ * booths — off it.
+ * @param point - Where on the plan the pointer is.
+ * @param def - The def the renderer hit, when it hit one.
+ * @returns The booth, or `null`.
+ */
+function boothAt(point, def) {
+    const byDef = def ? boothOfShape(def) : null;
+    if (byDef)
+        return byDef;
+    return getBoothIdFromClientXy(point.x, point.y);
+}
+/**
+ * What every click on the plan does regardless of what it hit: dismisses a full-height overlay,
+ * publishes the plan coordinates to the SDK, reports the click to the marker callback, and clears the
+ * external reset hook.
+ * @param point - Where on the plan the click landed.
+ * @param nativeEvent - The DOM click, whose screen position the PoI pins are tested at.
+ * @returns Whether the click should go on to change the selection; kiosk setup mode consumes it.
+ */
+function clickedPlan(point, nativeEvent) {
+    if (!uiState.rootElement)
+        return false;
+    resetExternalOverlay();
+    // Before the kiosk bail below, deliberately: kiosk setup is the main registrar, and its whole
+    // interest is clicks made while that mode is on.
+    planClickListener?.(point);
+    if (uiState.overlayPosition === 'bottom' && uiState.overlaySize === 'full') {
+        store.showMap();
+    }
+    if (uiState.onGetCoordsClick) {
+        const currentFloor = store.layerStore.layers.find((layer) => layer.visible && (layer.mode === LayerMode.TurnedOn || layer.mode === LayerMode.TurnedOff));
+        uiState.onGetCoordsClick({ x: point.x, y: point.y, z: currentFloor?.name || null });
+    }
+    if (uiState.setKioskModeEnabled)
+        return false;
+    // A click on an outdoor PoI symbol or cluster belongs to the map's own layers — usePoiMarkers
+    // handles it at map level — so the plan neither reports a marker nor selects the booth
+    // underneath. A no-op outside MapLibre mode: the test is registered only while those layers are.
+    // Tested at the click's screen position, not at `point`: a click that struck a model in front of
+    // a pin reports the model's elevated surface, which projects off the pin at ground level.
+    if (poiMarkerHitTest.test(nativeEvent.clientX, nativeEvent.clientY))
+        return false;
+    // Likewise for a tap on a degraded venue: useVenueLayers focuses the venue from its own
+    // map-level handler (KTD-6), so the plan must not also select the booth underneath — booth
+    // hit-testing is geometric and ignores `LayerDef.hidden`.
+    if (venueTapHitTest.test(point.x, point.y))
+        return false;
+    // Reported on every click, hit or miss, because that is the callback's contract — the host clears
+    // its own marker selection when a later click reaches none. Markers are not picked: they are tested
+    // against the click here, the way this has always resolved them, so a marker never swallows the
+    // click that the plan beneath it is also entitled to.
+    if (uiState.onMarkerClick) {
+        const marker = markerResolver?.(point.x, point.y) ?? null;
+        uiState.onMarkerClick(marker);
+    }
+    return true;
+}
+/**
+ * Calls the kiosk's idle-reset hook, if one is installed. A global (`window.__resett`), which is how
+ * the parts of the SDK that are not components reach the timer `init-ui` owns — and which an
+ * embedding page may install instead.
+ *
+ * Exported because the user moving the camera counts as activity too, not only a click: `MapCamera`
+ * calls it while the visitor has hold of the plan, as the imperative renderer's `navigation:change`
+ * listener did. A command is left out on purpose — the idle reset moves the camera itself, and would
+ * re-arm the timer it had just fired.
+ */
+export function resetExternalOverlay() {
+    if (typeof window === 'undefined')
+        return;
+    const reset = window.__resett;
+    reset?.();
+}
+/**
+ * Booth by background shape. Weak, so a booth's defs are collected with the plan they were built
+ * for — a re-configured plan simply registers new ones.
+ */
+const mapShapeToBooth = new WeakMap();
+/** How a click currently resolves to a marker; absent until markers are drawn. */
+let markerResolver;
+/** Who currently listens to plan clicks; absent outside kiosk setup and route authoring. */
+let planClickListener;

package/dist/esm/components/Map/scene.d.ts

@@ -0,0 +1,20 @@
+import { type SceneDef } from '@expofp/renderer';
+/**
+ * Publishes the scene the mounted map is drawing, for as long as it is on screen.
+ *
+ * The same inversion `setMapCamera` and `setMapViewport` perform, for the same callers: the parts
+ * of the SDK that are not components — the venue-fit resolution in `UIState.fitBounds`, the traffic
+ * hooks — need the def tree the map built, and the map is the one place that knows it. The
+ * imperative path parked the scene on `RendererService`; this hands it out without the service.
+ * @param scene - The scene; omitted to unpublish it as the map unmounts.
+ */
+export declare function setMapScene(scene?: SceneDef): void;
+/**
+ * The scene the mounted map is drawing, if one is on screen.
+ *
+ * Absent before the map has built its scene, and after it unmounts. In MapLibre mode the adapter
+ * publishes the embed's prepared scene the same way.
+ * @returns The scene, or `undefined`.
+ */
+export declare function mapScene(): SceneDef | undefined;
+//# sourceMappingURL=scene.d.ts.map

package/dist/esm/components/Map/scene.js

@@ -0,0 +1,24 @@
+/**
+ * Publishes the scene the mounted map is drawing, for as long as it is on screen.
+ *
+ * The same inversion `setMapCamera` and `setMapViewport` perform, for the same callers: the parts
+ * of the SDK that are not components — the venue-fit resolution in `UIState.fitBounds`, the traffic
+ * hooks — need the def tree the map built, and the map is the one place that knows it. The
+ * imperative path parked the scene on `RendererService`; this hands it out without the service.
+ * @param scene - The scene; omitted to unpublish it as the map unmounts.
+ */
+export function setMapScene(scene) {
+    published = scene;
+}
+/**
+ * The scene the mounted map is drawing, if one is on screen.
+ *
+ * Absent before the map has built its scene, and after it unmounts. In MapLibre mode the adapter
+ * publishes the embed's prepared scene the same way.
+ * @returns The scene, or `undefined`.
+ */
+export function mapScene() {
+    return published;
+}
+/** The scene the mounted map published, if there is one. */
+let published;

package/dist/esm/components/Map/traffic/UpdateQueue.d.ts

@@ -0,0 +1,13 @@
+export declare class UpdateQueue {
+    private queue;
+    private isProcessing;
+    private rafId;
+    private readonly CHUNK_SIZE;
+    private readonly TIME_BUDGET;
+    add(fn: () => void): void;
+    private scheduleProcessing;
+    private processMicrotaskQueue;
+    private processQueue;
+    destroy(): void;
+}
+//# sourceMappingURL=UpdateQueue.d.ts.map

package/dist/esm/components/Map/traffic/UpdateQueue.js

@@ -0,0 +1,82 @@
+export class UpdateQueue {
+    constructor() {
+        this.queue = [];
+        this.isProcessing = false;
+        this.rafId = null;
+        this.CHUNK_SIZE = 100; // Process N tasks at a time
+        this.TIME_BUDGET = 4; // 4ms to stay under 5ms threshold
+    }
+    add(fn) {
+        this.queue.push(fn);
+        this.scheduleProcessing();
+    }
+    scheduleProcessing() {
+        if (this.isProcessing || this.queue.length === 0)
+            return;
+        this.isProcessing = true;
+        // Try microtask first for immediate processing
+        if (this.queue.length <= this.CHUNK_SIZE * 2) {
+            Promise.resolve().then(() => this.processMicrotaskQueue());
+        }
+        // Fallback to RAF for larger queues
+        else {
+            this.rafId = requestAnimationFrame((timestamp) => {
+                this.processQueue(timestamp);
+            });
+        }
+    }
+    processMicrotaskQueue() {
+        const startTime = performance.now();
+        let processed = 0;
+        while (this.queue.length > 0 && processed < this.CHUNK_SIZE) {
+            const task = this.queue.shift();
+            try {
+                task();
+            }
+            catch (err) {
+                console.warn('UpdateQueue task error:', err);
+            }
+            processed++;
+            // Yield if we're approaching the budget
+            if (performance.now() - startTime > this.TIME_BUDGET)
+                break;
+        }
+        if (this.queue.length > 0) {
+            // Schedule next chunk
+            Promise.resolve().then(() => this.processMicrotaskQueue());
+        }
+        else {
+            this.isProcessing = false;
+        }
+    }
+    processQueue(startTime) {
+        this.rafId = null;
+        let processed = 0;
+        while (this.queue.length > 0 && processed < this.CHUNK_SIZE) {
+            const task = this.queue.shift();
+            try {
+                task();
+            }
+            catch (err) {
+                console.warn('UpdateQueue task error:', err);
+            }
+            processed++;
+            if (performance.now() - startTime > this.TIME_BUDGET)
+                break;
+        }
+        if (this.queue.length > 0) {
+            this.rafId = requestAnimationFrame((ts) => this.processQueue(ts));
+        }
+        else {
+            this.isProcessing = false;
+        }
+    }
+    destroy() {
+        if (this.rafId !== null) {
+            cancelAnimationFrame(this.rafId);
+            this.rafId = null;
+        }
+        this.queue = [];
+        this.isProcessing = false;
+    }
+}

package/dist/esm/components/Map/traffic/trafficLayers.d.ts

@@ -0,0 +1,12 @@
+export declare const TRAFFIC_ROUTE_PREFIX = "traffic_route";
+export declare const TRAFFIC_ROUTE_STOP_PREFIX = "traffic_route_stop";
+export declare const TRAFFIC_VEHICLES = "traffic_vehicles";
+export declare const BUILD_ROUTE_LINES = "build_route_lines";
+export declare const BUILD_ROUTE_DOTS = "build_route_dots";
+export declare function createTrafficLayers(): {
+    name: string;
+    children: never[];
+}[];
+export declare function getRouteLayerRegex(): RegExp;
+export declare function getRouteStopLayerRegex(): RegExp;
+//# sourceMappingURL=trafficLayers.d.ts.map

package/dist/esm/components/Map/traffic/trafficLayers.js

@@ -0,0 +1,29 @@
+export const TRAFFIC_ROUTE_PREFIX = 'traffic_route';
+export const TRAFFIC_ROUTE_STOP_PREFIX = 'traffic_route_stop';
+export const TRAFFIC_VEHICLES = 'traffic_vehicles';
+export const BUILD_ROUTE_LINES = 'build_route_lines';
+export const BUILD_ROUTE_DOTS = 'build_route_dots';
+const ROUTE_LIMIT = 5;
+export function createTrafficLayers() {
+    const result = [];
+    for (let i = 0; i < ROUTE_LIMIT; i++) {
+        result.push({ name: getRouteLayerName(i), children: [] });
+        result.push({ name: getRouteStopLayerName(i), children: [] });
+    }
+    result.push({ name: TRAFFIC_VEHICLES, children: [] });
+    result.push({ name: BUILD_ROUTE_LINES, children: [] });
+    result.push({ name: BUILD_ROUTE_DOTS, children: [] });
+    return result;
+}
+function getRouteLayerName(i) {
+    return `${TRAFFIC_ROUTE_PREFIX}_${i + 1}`;
+}
+function getRouteStopLayerName(i) {
+    return `${TRAFFIC_ROUTE_STOP_PREFIX}_${i + 1}`;
+}
+export function getRouteLayerRegex() {
+    return new RegExp(`^${TRAFFIC_ROUTE_PREFIX}_\\d+$`);
+}
+export function getRouteStopLayerRegex() {
+    return new RegExp(`^${TRAFFIC_ROUTE_STOP_PREFIX}_\\d+$`);
+}

package/dist/esm/components/Map/traffic/useBuildRoute.d.ts

@@ -0,0 +1,9 @@
+import { type SceneDef } from '@expofp/renderer';
+export interface BuildRouteParams {
+    enabled: boolean;
+    /** The scene whose build-route layers this draws into. */
+    scene: SceneDef | undefined;
+    cb?: () => void;
+}
+export declare function useBuildRoute({ enabled, scene }: BuildRouteParams): void;
+//# sourceMappingURL=useBuildRoute.d.ts.map