@expofp/floorplan 0.0.0-experimental.2d6c681

package/dist/esm/wayfinding/bindMobxReactions.js

@@ -0,0 +1,171 @@
+import { comparer, reaction } from 'mobx';
+import { boothToEndpoint, CURRENT_LOCATION_NAME, CURRENT_POSITION_POINT_ID, positionInput, toArbitraryPoint, } from './adapters';
+const toEndpoint = (value) => 'rect' in value ? boothToEndpoint(value) : value;
+/**
+ * Wires the observable efp stores to the imperative wayfinding instance and
+ * the efp-side kiosk/yah handlers. Each reaction translates observable
+ * changes into neutral-typed imperative calls.
+ *
+ * Triggers `routeStore.rebuildRouteFromPosition` (via `wayfinding.shouldReroute`) when
+ * the live CP needs to become (or refresh) the route's FROM.
+ *
+ * Returns a dispose function that tears down all reactions plus the deferred
+ * floor-change timeout.
+ */
+export function bindMobxReactions({ wayfinding, kioskHandler, yahHandler, stores: { routeStore, uiState, layerStore }, }) {
+    const disposers = [];
+    function applyRoute() {
+        const route = uiState.selectedRoute;
+        const from = route?.from ? toEndpoint(route.from) : null;
+        const to = route?.to ? toEndpoint(route.to) : null;
+        if (!from || !to) {
+            wayfinding.clearRoute();
+            routeStore.markRouted(route);
+            return;
+        }
+        const isRouteBuilt = wayfinding.setRoute({
+            from,
+            to,
+            waypoints: route?.waypoints?.map(boothToEndpoint),
+            accessible: routeStore.onlyAccessible,
+        });
+        routeStore.markRouted(route);
+        if (isRouteBuilt === false) {
+            console.error(new Error(`Route not found: (${from.x},${from.y}) → (${to.x},${to.y})`));
+        }
+    }
+    function applyPosition() {
+        const position = routeStore.currentPosition;
+        const isYahMode = routeStore.iconType !== 0;
+        const selectedRoute = uiState.selectedRoute;
+        const hasActiveRoute = !!(selectedRoute?.from && selectedRoute?.to);
+        const showYah = isYahMode && !hasActiveRoute;
+        if (!position) {
+            wayfinding.setPosition(null);
+            yahHandler(null);
+            return;
+        }
+        const input = positionInput(position);
+        if (showYah) {
+            wayfinding.setPosition(null);
+            yahHandler({ x: input.x, y: input.y, layer: input.layer });
+        }
+        else {
+            yahHandler(null);
+            wayfinding.setPosition(input);
+        }
+    }
+    // CP-driven reroute
+    function syncRouteWithPosition() {
+        const position = routeStore.currentPosition;
+        const selectedRoute = uiState.selectedRoute;
+        if (!position || !selectedRoute?.to)
+            return;
+        const needsInitialFrom = !selectedRoute.from;
+        const isCpAnchored = selectedRoute.from?.id === CURRENT_POSITION_POINT_ID;
+        const drifted = isCpAnchored && wayfinding.shouldReroute(positionInput(position));
+        if (!needsInitialFrom && !drifted)
+            return;
+        routeStore.rebuildRouteFromPosition(toArbitraryPoint(position, CURRENT_LOCATION_NAME, CURRENT_POSITION_POINT_ID));
+    }
+    function applyKiosk() {
+        kioskHandler(uiState.kioskData ?? null);
+    }
+    function visibleLayerNames() {
+        return layerStore.layers.filter((layer) => layer.visible).map((layer) => layer.name);
+    }
+    // Recovery for the case where `wayfinding.setRoute` returned false (no path
+    // found from the auto-pinned CP). `routeLines` stays empty, so the
+    // controller's `shouldReroute` short-circuits on `!routeLines.length` and
+    // never retries. Lives in the CP-reaction only (not inside applyPosition)
+    // to avoid looping through the selectedRoute reaction.
+    function retryAutoFromIfBuildFailed() {
+        const route = uiState.selectedRoute;
+        const position = routeStore.currentPosition;
+        if (!route?.to || !position)
+            return;
+        if (route.from?.id !== CURRENT_POSITION_POINT_ID)
+            return;
+        if (routeStore.routeLines.length > 0)
+            return;
+        const positionLayer = position.z != null ? String(position.z) : '';
+        const sameCoords = route.from.x === position.x &&
+            route.from.y === position.y &&
+            route.from.layer === positionLayer;
+        if (sameCoords)
+            return;
+        routeStore.rebuildRouteFromPosition(toArbitraryPoint(position, CURRENT_LOCATION_NAME, CURRENT_POSITION_POINT_ID));
+    }
+    disposers.push(reaction(() => layerStore.layersLoaded, () => {
+        applyRoute();
+        applyPosition();
+    }), reaction(() => [uiState.selectedRoute, routeStore.onlyAccessible], () => {
+        applyRoute();
+        applyPosition();
+    }), 
+    // A fresh CurrentPosition instance with the same fix must not reach the renderer: redrawing the
+    // route for it is what made the line blink on every tick. The heading stays in the key so a
+    // compass-only tick still turns the icon, and the icon type because `selectCurrentPosition`
+    // flips it in the same action — a same-fix call that only changes the icon must still apply.
+    reaction(() => {
+        const position = routeStore.currentPosition;
+        return position
+            ? {
+                x: position.x,
+                y: position.y,
+                z: position.z,
+                angle: position.angle,
+                iconType: routeStore.iconType,
+            }
+            : null;
+    }, () => {
+        applyPosition();
+    }, { equals: comparer.structural }), 
+    // Route mutations react to actual coordinate changes only — a fresh CurrentPosition instance with
+    // the same x/y/z (e.g. a compass-only tick) must not re-trigger reroute logic.
+    reaction(() => {
+        const position = routeStore.currentPosition;
+        return position ? { x: position.x, y: position.y, z: position.z } : null;
+    }, () => {
+        syncRouteWithPosition();
+        retryAutoFromIfBuildFailed();
+    }, { equals: comparer.structural }), 
+    // The handler scopes the icon to the shown floors through `FloorContext`, so re-apply on
+    // visibility changes. Structural: every apply rebuilds the icon canvas, so a `layers`
+    // recompute that leaves the shown set unchanged must not fire.
+    reaction(() => [uiState.kioskData, layerStore.mode, visibleLayerNames()], () => applyKiosk(), { equals: comparer.structural }));
+    // setTimeout(0) workaround from config-wf.ts Reaction 2 — defers floor-layer
+    // changes so layer visibility writes settle before the route re-renders.
+    // Visible layers are a dependency too: the active floors are read from
+    // visibility, and a venue level turns visible only after it loads — later
+    // than the route layer that names it.
+    let floorTimeout = null;
+    const floorDisposer = reaction(() => [routeStore.currentRouteLayer, uiState.getRouteNextFloor, visibleLayerNames().join('\n')], () => {
+        if (!layerStore.layersLoaded)
+            return;
+        if (floorTimeout !== null)
+            clearTimeout(floorTimeout);
+        floorTimeout = setTimeout(() => {
+            wayfinding.notifyFloorChanged();
+            applyPosition();
+            floorTimeout = null;
+        }, 0);
+    });
+    disposers.push(() => {
+        if (floorTimeout !== null)
+            clearTimeout(floorTimeout);
+        floorDisposer();
+    });
+    // MobX reactions don't fire on registration. If the observed values were
+    // already populated before wiring (e.g. `layersLoaded` is true by the time
+    // `createWayfinding()` runs), we need an explicit initial sync so the
+    // first route/position/kiosk state lands on the renderer.
+    applyRoute();
+    applyPosition();
+    applyKiosk();
+    return () => {
+        for (const dispose of disposers)
+            dispose();
+        disposers.length = 0;
+    };
+}

package/dist/esm/wayfinding/createWayfinding.d.ts

@@ -0,0 +1,34 @@
+import { type SceneDef } from '@expofp/renderer';
+import { type Route, type RouteEndpoint } from '@expofp/wayfinding';
+import type RootStore from '../store/RootStore';
+/** Whether `createWayfinding` has run and not yet been disposed. */
+export declare function isWayfindingReady(): boolean;
+/**
+ * Build a route between two endpoints. Throws if wayfinding is not initialized.
+ *
+ * TODO: compromise for the public SDK (`RouteStore.checkRoutes` diagnostic). Ad-hoc
+ * route building should not be a public capability — routing belongs to the runtime.
+ * Remove once the SDK surface no longer needs standalone route checks.
+ */
+export declare function buildRoute(from: RouteEndpoint, to: RouteEndpoint, options?: {
+    accessible?: boolean;
+}): Route;
+/** What {@link createWayfinding} needs: a scene to draw into, and the stores to observe. */
+export interface WayfindingOptions {
+    /** The scene wayfinding fills; its root layers hold the block `configAll` mounted. */
+    readonly scene: SceneDef;
+    /** The app store. */
+    readonly store: RootStore;
+    /** A ref holding canvas that's rendering floorplan */
+    readonly canvas: {
+        readonly current: HTMLCanvasElement | null;
+    };
+}
+/**
+ * Starts wayfinding on a `@expofp/renderer` scene: builds the engine and runtime, binds them to
+ * the stores, and declares the layout and pointer rules the renderer dispatches.
+ * @param options - The scene and the store.
+ * @returns A disposer.
+ */
+export declare function createWayfinding(options: WayfindingOptions): () => void;
+//# sourceMappingURL=createWayfinding.d.ts.map

package/dist/esm/wayfinding/createWayfinding.js

@@ -0,0 +1,184 @@
+import { getConfig } from '@expofp/config';
+import { update } from '@expofp/renderer';
+import { createWayfinding as createWayfindingInstance, resolveWayfindingLayers, } from '@expofp/wayfinding';
+import { getFpGeo } from '../data/fpGeo.js';
+import { attachCardinalSnap } from '../engine/utils/rotation';
+import { createCanvasIconProvider, createFloorContext, createGraphDataSource, withCampusEndpoints, } from './adapters';
+import { bindMobxReactions } from './bindMobxReactions';
+import { createKioskHandler } from './handlers/kioskHandler';
+import { createYahHandler } from './handlers/yahHandler';
+/**
+ * The single active wayfinding for the current page — set by `createWayfinding`,
+ * cleared by its disposer. App-level glue: the reusable package stays stateless,
+ * so the app owns the one active instance. Assumes a single active floorplan per
+ * app (a second `createWayfinding()` replaces the first).
+ */
+let activeWayfinding = null;
+/** Whether `createWayfinding` has run and not yet been disposed. */
+export function isWayfindingReady() {
+    return activeWayfinding !== null;
+}
+function requireWayfinding() {
+    if (!activeWayfinding) {
+        throw new Error('Wayfinding is not initialized — call createWayfinding() first.');
+    }
+    return activeWayfinding;
+}
+/**
+ * Build a route between two endpoints. Throws if wayfinding is not initialized.
+ *
+ * TODO: compromise for the public SDK (`RouteStore.checkRoutes` diagnostic). Ad-hoc
+ * route building should not be a public capability — routing belongs to the runtime.
+ * Remove once the SDK surface no longer needs standalone route checks.
+ */
+export function buildRoute(from, to, options) {
+    return requireWayfinding().wayfinding.buildRoute(from, to, options);
+}
+/**
+ * Starts wayfinding on a `@expofp/renderer` scene: builds the engine and runtime, binds them to
+ * the stores, and declares the layout and pointer rules the renderer dispatches.
+ * @param options - The scene and the store.
+ * @returns A disposer.
+ */
+export function createWayfinding(options) {
+    const { scene, store, canvas } = options;
+    const layers = resolveWayfindingLayers(scene.rootLayer);
+    const { wayfinding, dispose } = start(store, layers, { attachCardinalSnap, update });
+    const iconsLayer = layers.icons;
+    // Declaring handlers is what makes a layer pickable, so this is also what keeps the rest of the
+    // block — trails, both line layers, the current position — out of raycasting entirely.
+    iconsLayer.onClick = (event) => handleIconClick(wayfinding, event);
+    iconsLayer.onPointerMove = (event) => reportHover(wayfinding, canvas, event);
+    iconsLayer.onPointerOut = () => reportHover(wayfinding, canvas);
+    update(iconsLayer);
+    return () => {
+        iconsLayer.onClick = undefined;
+        iconsLayer.onPointerMove = undefined;
+        iconsLayer.onPointerOut = undefined;
+        if (canvas.current)
+            canvas.current.style.cursor = '';
+        update(iconsLayer);
+        dispose();
+    };
+}
+/**
+ * Builds the engine, runtime and reactions, leaving the caller to wire the camera and the
+ * pointer on top.
+ * @param store - The app store.
+ * @param layers - The layers wayfinding fills.
+ * @param port - The host's roll rule and the commit function.
+ * @returns The instance and a disposer.
+ */
+function start(store, layers, port) {
+    const dataSource = createGraphDataSource(store.venueStore);
+    const wfColors = getConfig().wayfindingColors ?? {};
+    const iconProvider = createCanvasIconProvider({
+        iconMap: store.fp.icons,
+        pixelRatio: devicePixelRatio,
+        sourceColor: wfColors.source,
+        destinationColor: wfColors.destination,
+    });
+    const floorContext = createFloorContext(store.layerStore, store.routeStore, store.venueStore, dataSource);
+    const wayfindingInstance = createWayfindingInstance({
+        dataSource,
+        renderer: port,
+        rendererConfig: {
+            colors: {
+                ...(wfColors.route && { remaining: wfColors.route }),
+                ...(wfColors.routeActive && { active: wfColors.routeActive }),
+                ...(wfColors.routePassed && { passed: wfColors.routePassed }),
+            },
+        },
+        iconProvider,
+        floorContext,
+        layers,
+        gpsConfig: getFpGeo()?.properties?.config,
+        // In 3D an icon lying on the floor reads as a smear under tilt, so every icon stands up to
+        // face the viewer. The same venue flag drives the overlay tier in `configAll`.
+        screenSpaceIcons: store.uiState.is3DView,
+        onTransitionClick: (point) => {
+            if (point.role === 'exit')
+                store.layerStore.updateVisibility(point.targetLayer, true);
+        },
+        onRouteUpdate: (lines, bounds) => {
+            store.routeStore.updateRoute([...lines], dataSource.getCampusLayers());
+            if (!bounds.isEmpty()) {
+                store.uiState.moveToRect = bounds;
+            }
+        },
+        onRouteDistance: (distance) => store.routeStore.updateRouteDistance(distance),
+    });
+    const wayfinding = withCampusEndpoints(wayfindingInstance, dataSource);
+    const kioskHandler = createKioskHandler({
+        wayfinding,
+        kioskIconMap: store.fp.icons,
+        floorContext,
+    });
+    const yahHandler = createYahHandler({
+        wayfinding,
+        iconMap: store.fp.icons,
+        pixelRatio: devicePixelRatio,
+        floorContext,
+    });
+    const disposeReactions = bindMobxReactions({
+        wayfinding,
+        kioskHandler,
+        yahHandler,
+        stores: { routeStore: store.routeStore, uiState: store.uiState, layerStore: store.layerStore },
+    });
+    // efp-specific toggle derived in glue (not in the package engine):
+    store.routeStore.showAccessible = dataSource.getLines().some((line) => line.unaccessible);
+    const instance = { wayfinding };
+    activeWayfinding = instance;
+    wayfinding.flush();
+    return {
+        wayfinding,
+        dispose() {
+            // Shared store state is global, so only the still-active instance may reset it.
+            if (isActive(instance)) {
+                activeWayfinding = null;
+                store.routeStore.showAccessible = false;
+                store.routeStore.markRouted(null);
+            }
+            disposeReactions();
+            wayfinding.destroy();
+        },
+    };
+}
+/**
+ * Whether an instance is still the live one — a stale disposer must not undo a newer start's work.
+ * @param instance - The registration to check.
+ * @returns Whether it is still active.
+ */
+function isActive(instance) {
+    return activeWayfinding === instance;
+}
+/**
+ * Runs a clicked wayfinding icon's callback.
+ * @param wayfinding - The instance that owns the icons.
+ * @param event - The def that was clicked.
+ */
+function handleIconClick(wayfinding, event) {
+    if (!wayfinding.handleClick([event.def]))
+        return;
+    // The icon consumed this click, so nothing underneath it should also act on it — a pin drawn over
+    // a booth must not select that booth, and a click reaching no handler at all deselects.
+    event.stopPropagation();
+}
+/**
+ * Points the cursor at a clickable wayfinding icon, and clears it again once the pointer leaves one.
+ *
+ * The canvas arrives as a ref rather than an element because the caller mounts it: a ref read at
+ * event time is current whatever React did to the canvas since, and is `null` before it mounts —
+ * which is exactly when there is nothing to point at anyway.
+ * @param wayfinding - The instance that owns the icons.
+ * @param canvas - A ref to the canvas whose cursor to set.
+ * @param event - The def under the pointer, or nothing when the pointer left one.
+ */
+function reportHover(wayfinding, canvas, event) {
+    const element = canvas.current;
+    if (!element)
+        return;
+    const hovered = event ? wayfinding.handleHover([event.def]) : false;
+    element.style.cursor = hovered ? 'pointer' : '';
+}

package/dist/esm/wayfinding/handlers/kioskHandler.d.ts

@@ -0,0 +1,26 @@
+import type { FloorContext, Wayfinding } from '@expofp/wayfinding';
+import type { Kiosk } from '../../components/Kiosk/SetKiosk';
+/**
+ * Updates the kiosk icon in response to store changes.
+ *
+ * @param kiosk  Current kiosk data, or null when kiosk mode is off.
+ */
+export type KioskHandler = (kiosk: Kiosk | null) => void;
+/**
+ * Creates a kiosk-icon handler that lives outside the wayfinding runtime.
+ *
+ * Kiosk is an efp-specific map annotation — not part of the route. Keeping it
+ * next to `createWayfinding.ts` (rather than in `runtime/`) preserves the
+ * runtime's portability: the runtime deals with source/destination/position/
+ * transitions only, and never learns that kiosks exist.
+ *
+ * On a floor-scoped plan the icon shows only while the floor the kiosk stands
+ * on is on screen (one floor on a single-venue plan, one level per venue on a
+ * multi-venue map), as `floorContext` reports it.
+ */
+export declare function createKioskHandler({ wayfinding, kioskIconMap, floorContext, }: {
+    wayfinding: Pick<Wayfinding, 'setIcon' | 'flush'>;
+    kioskIconMap: Map<string, HTMLImageElement> | undefined;
+    floorContext: FloorContext;
+}): KioskHandler;
+//# sourceMappingURL=kioskHandler.d.ts.map

package/dist/esm/wayfinding/handlers/kioskHandler.js

@@ -0,0 +1,52 @@
+import { degToRad } from '@expofp/geometry';
+import { cssSizeOf } from '../../components/Map/drawing/config/canvases';
+import { createKioskCanvas } from '../adapters';
+const KIOSK_ICON_KEY = 'kiosk';
+/**
+ * Creates a kiosk-icon handler that lives outside the wayfinding runtime.
+ *
+ * Kiosk is an efp-specific map annotation — not part of the route. Keeping it
+ * next to `createWayfinding.ts` (rather than in `runtime/`) preserves the
+ * runtime's portability: the runtime deals with source/destination/position/
+ * transitions only, and never learns that kiosks exist.
+ *
+ * On a floor-scoped plan the icon shows only while the floor the kiosk stands
+ * on is on screen (one floor on a single-venue plan, one level per venue on a
+ * multi-venue map), as `floorContext` reports it.
+ */
+export function createKioskHandler({ wayfinding, kioskIconMap, floorContext, }) {
+    // Built once per icon size and kept: `createKioskCanvas` allocates, and `setIcon` recreates the
+    // def whenever the canvas identity changes — which would discard and re-upload the icon on every
+    // kiosk update.
+    const canvasesBySize = new Map();
+    const canvasForSize = (iconSizePercent) => {
+        const key = iconSizePercent ?? 100;
+        const cached = canvasesBySize.get(key);
+        if (cached)
+            return cached;
+        const canvas = createKioskCanvas(kioskIconMap, iconSizePercent);
+        canvasesBySize.set(key, canvas);
+        return canvas;
+    };
+    return (kiosk) => {
+        const floorShown = floorContext.showAllFloors() || !kiosk?.z || floorContext.isLayerVisible(kiosk.z);
+        if (!kiosk || !floorShown) {
+            wayfinding.setIcon(KIOSK_ICON_KEY, null);
+            wayfinding.flush();
+            return;
+        }
+        const canvas = canvasForSize(kiosk.iconSizePercent);
+        wayfinding.setIcon(KIOSK_ICON_KEY, {
+            canvas,
+            ...cssSizeOf(canvas),
+            x: kiosk.x,
+            y: kiosk.y,
+            rotation: degToRad(kiosk.heading ?? 0),
+            // The heading is which way the physical device faces, so it is a direction in the venue and
+            // the marker stays flat on the plan. A screen-space def spins about the screen's normal and
+            // would point at one screen direction however the plan is turned.
+            screenSpace: false,
+        });
+        wayfinding.flush();
+    };
+}

package/dist/esm/wayfinding/handlers/yahHandler.d.ts

@@ -0,0 +1,21 @@
+import type { FloorContext, Wayfinding } from '@expofp/wayfinding';
+/**
+ * Places or hides the "You Are Here" marker. An efp-specific map annotation
+ * (shown when `routeStore.iconType !== 0` and no active route) — separated
+ * from the core runtime so the runtime never learns that YAH exists.
+ *
+ * Mutually exclusive with the runtime's position icon: `bindMobxReactions`
+ * orchestrates so that only one of the two is visible at any time.
+ */
+export type YahHandler = (position: {
+    readonly x: number;
+    readonly y: number;
+    readonly layer: string;
+} | null) => void;
+export declare function createYahHandler({ wayfinding, iconMap, pixelRatio, floorContext, }: {
+    wayfinding: Pick<Wayfinding, 'setIcon' | 'flush'>;
+    iconMap: Map<string, HTMLImageElement>;
+    pixelRatio: number;
+    floorContext: FloorContext;
+}): YahHandler;
+//# sourceMappingURL=yahHandler.d.ts.map

package/dist/esm/wayfinding/handlers/yahHandler.js

@@ -0,0 +1,42 @@
+import { createImageCanvas, createYahCanvas, cssSizeOf, } from '../../components/Map/drawing/config/canvases';
+import { decreaseByPercentage } from '../../utils/math';
+const YAH_ICON_KEY = 'yah';
+const YAH_FALLBACK_COLOR = '#ff4343';
+// Custom YAH image is drawn at 32% smaller than its native 64×90.
+const YAH_IMAGE_WIDTH = 64;
+const YAH_IMAGE_HEIGHT = 90;
+const YAH_IMAGE_SIZE_REDUCTION_PERCENT = 32;
+/**
+ * Builds the YAH canvas from the store icon map, falling back to the drawn
+ * marker. Kept here so the efp-only `'yah'` icon never leaves the handler.
+ */
+function resolveYahCanvas(iconMap, pixelRatio) {
+    const image = iconMap.get(YAH_ICON_KEY);
+    if (image) {
+        image.id = YAH_ICON_KEY;
+        return createImageCanvas(image, decreaseByPercentage(YAH_IMAGE_WIDTH, YAH_IMAGE_SIZE_REDUCTION_PERCENT), decreaseByPercentage(YAH_IMAGE_HEIGHT, YAH_IMAGE_SIZE_REDUCTION_PERCENT), pixelRatio);
+    }
+    return createYahCanvas(pixelRatio, YAH_FALLBACK_COLOR);
+}
+export function createYahHandler({ wayfinding, iconMap, pixelRatio, floorContext, }) {
+    const yahCanvas = resolveYahCanvas(iconMap, pixelRatio);
+    yahCanvas.id = 'current-location-2';
+    return (position) => {
+        if (!position) {
+            wayfinding.setIcon(YAH_ICON_KEY, null);
+            wayfinding.flush();
+            return;
+        }
+        const layerVisible = floorContext.isLayerVisible(position.layer);
+        wayfinding.setIcon(YAH_ICON_KEY, {
+            canvas: yahCanvas,
+            ...cssSizeOf(yahCanvas),
+            x: position.x,
+            y: position.y,
+            hidden: !layerVisible,
+            dimmed: !layerVisible,
+            origin: [0.5, 1],
+        });
+        wayfinding.flush();
+    };
+}

package/dist/esm/wayfinding/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * efp-side wayfinding facade — the single entry the floorplan app imports from
+ * (stores, mount points). Re-exports the bootstrap (`createWayfinding`), the
+ * runtime facade (`isWayfindingReady`), and the glue endpoint helpers.
+ */
+export type { ArbitraryPoint } from './adapters';
+export { boothToEndpoint, CURRENT_LOCATION_NAME, CURRENT_POSITION_POINT_ID, KIOSK_ANCHOR_POINT_ID, toArbitraryPoint, } from './adapters';
+export { buildRoute } from './createWayfinding';
+export { createWayfinding, isWayfindingReady } from './createWayfinding';
+export { routeSteps } from './routeSteps';
+export type { RouteLine } from '@expofp/wayfinding';
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/wayfinding/index.js

@@ -0,0 +1,9 @@
+/**
+ * efp-side wayfinding facade — the single entry the floorplan app imports from
+ * (stores, mount points). Re-exports the bootstrap (`createWayfinding`), the
+ * runtime facade (`isWayfindingReady`), and the glue endpoint helpers.
+ */
+export { boothToEndpoint, CURRENT_LOCATION_NAME, CURRENT_POSITION_POINT_ID, KIOSK_ANCHOR_POINT_ID, toArbitraryPoint, } from './adapters';
+export { buildRoute } from './createWayfinding';
+export { createWayfinding, isWayfindingReady } from './createWayfinding';
+export { routeSteps } from './routeSteps';

package/dist/esm/wayfinding/routeSteps.d.ts

@@ -0,0 +1,15 @@
+/**
+ * The floors a route steps through, for the route panel's floor selector.
+ *
+ * A campus graph shared by several venues (see `createGraphDataSource`) labels
+ * its legs with each venue's ground level and the outdoor `WF*` layer, so a
+ * walk from hall to hall reads as a change of layer at every door. Doors are no
+ * floor change: each run of consecutive campus legs is one step, named by its
+ * first floor. Legs on layers the author drew separately keep a step each.
+ * @param layers - The route's layers in walking order, each once.
+ * @param campusLayers - The layers the campus graph's legs run on.
+ * @param isFloor - Whether a layer is a plan floor the panel can switch to.
+ * @returns The layers to list as steps.
+ */
+export declare function routeSteps(layers: readonly string[], campusLayers: ReadonlySet<string>, isFloor: (layer: string) => boolean): string[];
+//# sourceMappingURL=routeSteps.d.ts.map

package/dist/esm/wayfinding/routeSteps.js

@@ -0,0 +1,29 @@
+/**
+ * The floors a route steps through, for the route panel's floor selector.
+ *
+ * A campus graph shared by several venues (see `createGraphDataSource`) labels
+ * its legs with each venue's ground level and the outdoor `WF*` layer, so a
+ * walk from hall to hall reads as a change of layer at every door. Doors are no
+ * floor change: each run of consecutive campus legs is one step, named by its
+ * first floor. Legs on layers the author drew separately keep a step each.
+ * @param layers - The route's layers in walking order, each once.
+ * @param campusLayers - The layers the campus graph's legs run on.
+ * @param isFloor - Whether a layer is a plan floor the panel can switch to.
+ * @returns The layers to list as steps.
+ */
+export function routeSteps(layers, campusLayers, isFloor) {
+    const steps = [];
+    let campusRunStep = null;
+    for (const layer of layers) {
+        if (!campusLayers.has(layer)) {
+            campusRunStep = null;
+            steps.push(layer);
+            continue;
+        }
+        if (campusRunStep === null && isFloor(layer)) {
+            campusRunStep = layer;
+            steps.push(layer);
+        }
+    }
+    return steps;
+}

package/dist/esm/wayfinding/storePorts.d.ts

@@ -0,0 +1,67 @@
+import type { Box } from '@expofp/geometry';
+import type { Kiosk } from '../components/Kiosk/SetKiosk/types';
+import type { ArbitraryPoint } from './adapters';
+/**
+ * Structural read-model ports for {@link bindMobxReactions}.
+ *
+ * The glue only reads raw observables off the efp stores, so these are type-only
+ * shapes the concrete `RouteStore` / `UIState` / `LayerStore` satisfy structurally
+ * — the live instances pass straight through, MobX tracking is preserved, and the
+ * glue stays free of `store/*` types.
+ */
+/** Booth-shaped endpoint, narrowed to what the glue + `boothToEndpoint` read. */
+export interface BoothSource {
+    /** `number` (efp `Booth.id`) — discriminates against `ArbitraryPoint`'s string id. */
+    readonly id: number;
+    readonly rect: Box;
+    readonly rotate: number;
+    readonly layer?: {
+        readonly name: string;
+    } | null;
+    readonly innermostLayer?: {
+        readonly name: string;
+    } | null;
+}
+export type RouteEndpointSource = BoothSource | ArbitraryPoint;
+export interface RouteView {
+    readonly from: RouteEndpointSource | null;
+    readonly to: RouteEndpointSource | null;
+    readonly waypoints?: readonly BoothSource[];
+}
+/** User position the glue feeds to `positionInput` / `toArbitraryPoint`. */
+export interface PositionView {
+    readonly x: number;
+    readonly y: number;
+    readonly z?: number | string;
+    readonly angle?: number;
+}
+export interface RouteStorePort {
+    readonly currentPosition: PositionView | null;
+    readonly iconType: number;
+    readonly onlyAccessible: boolean;
+    /** Only `.length` is read (route-built recovery check). */
+    readonly routeLines: readonly unknown[];
+    readonly currentRouteLayer: {
+        readonly name: string;
+    } | null;
+    rebuildRouteFromPosition(from: ArbitraryPoint): void;
+    /** Records the route the engine has just routed, so `routeLines` are known to be its answer. */
+    markRouted(route: RouteView | null): void;
+}
+export interface UiStatePort {
+    readonly selectedRoute: RouteView | null;
+    readonly kioskData: Kiosk | null | undefined;
+    /** Reaction dependency only. */
+    readonly getRouteNextFloor: string | null;
+}
+export interface LayerStorePort {
+    /** Reaction dependency only: the kiosk handler reads floor scoping through `FloorContext`. */
+    readonly mode: number;
+    readonly layersLoaded: boolean;
+    /** Only `name` / `visible` are read (floor-change reaction dependency). */
+    readonly layers: readonly {
+        readonly name: string;
+        readonly visible: boolean;
+    }[];
+}
+//# sourceMappingURL=storePorts.d.ts.map