@expofp/floorplan 3.2.5 → 3.2.7

package/dist/esm/utils/gps.js

@@ -1 +1 @@
-import{getAngle as I,lineAngle as y,lineCenter as D,lineLength as h,rotatePoint as G,shiftPoint as L}from"simple-geometry";import x from"../tools/logger";import{fpGeo as R}from"../data/fpGeo";const B=6371e3,g=-180,S=180;let v=n=>n*Math.PI/180,d=n=>n*180/Math.PI;export function distance(n,l,t,s){const r=n*Math.PI/180,e=t*Math.PI/180,p=(t-n)*Math.PI/180,c=(s-l)*Math.PI/180,i=Math.sin(p/2)*Math.sin(p/2)+Math.cos(r)*Math.cos(e)*Math.sin(c/2)*Math.sin(c/2);return 6371e3*(2*Math.atan2(Math.sqrt(i),Math.sqrt(1-i)))}export function bearing(n,l,t,s){const a=n*Math.PI/180,r=t*Math.PI/180,e=(s-l)*Math.PI/180,p=Math.sin(e)*Math.cos(r),c=Math.cos(a)*Math.sin(r)-Math.sin(a)*Math.cos(r)*Math.cos(e);return(Math.atan2(p,c)*180/Math.PI+360)%360}export function isValidPointCoords(n){return typeof n=="number"&&Number.isFinite(n)}export function convertGpsToLocal({lat:n,lng:l,angle:t},s){if(!(isValidPointCoords(n)&&isValidPointCoords(l)))return null;let{p0:a,p2:r}=s;const e=distance(a.lat,a.lng,r.lat,r.lng),p=bearing(a.lat,a.lng,r.lat,r.lng),c=h(a,r),i=y(a,r);let o=distance(a.lat,a.lng,n,l),u=bearing(a.lat,a.lng,n,l)-p;if(!isValidPointCoords(e)||e<=0)return x.warn("Invalid GPS config: zero or negative distance",{fullGpsDistance:e,p0:a,p2:r}),null;let m=o/e,P=G(u,L(a,c*m,i),a.x,a.y),b=h(P,D(s.p0,s.p2)),A=h(s.p0,s.p2);return b>5*A?(x.warn("Current position too far"),null):{...P,angle:t}}export function convertLocalToGps(n,l,t){var s=-I(t.p0,t.p2,{x:t.p0.x+1e4,y:t.p0.y}),a=-I(t.p0,{x:n,y:l},{x:t.p0.x+1e4,y:t.p0.y}),r=a-s,e=h(t.p2,t.p0),p=h(t.p0,{x:n,y:l}),c=p/e,i=distance(t.p0.lat,t.p0.lng,t.p2.lat,t.p2.lng),o=c*i,M=bearing(t.p0.lat,t.p0.lng,t.p2.lat,t.p2.lng),u=T(t.p0.lat,t.p0.lng,o,M+r);return u}function T(n,l,t,s){var a=t/B,r=v(s),e=v(n),p=v(l),c=Math.asin(Math.sin(e)*Math.cos(a)+Math.cos(e)*Math.sin(a)*Math.cos(r)),i=p+Math.atan2(Math.sin(r)*Math.sin(a)*Math.cos(e),Math.cos(a)-Math.sin(e)*Math.sin(c)),o=d(i);return(o<g||o>S)&&(i=(i+3*Math.PI)%(2*Math.PI)-Math.PI,o=d(i)),[o,d(c)]}export function calculateRelativeBearing(n){const l=R?.properties?.config?.bearing??0;return n?.angle===null?0:(((n.angle-l)%360+360)%360-90+360)%360}
+import{getAngle as x,lineAngle as y,lineCenter as G,lineLength as h,rotatePoint as L,shiftPoint as B}from"simple-geometry";import b from"../tools/logger";import{fpGeo as R}from"../data/fpGeo";import{haversineDistance as u}from"./haversineDistance";const g=6371e3,S=-180,T=180;let v=n=>n*Math.PI/180,d=n=>n*180/Math.PI;export function bearing(n,l,t,s){const a=n*Math.PI/180,r=t*Math.PI/180,e=(s-l)*Math.PI/180,o=Math.sin(e)*Math.cos(r),c=Math.cos(a)*Math.sin(r)-Math.sin(a)*Math.cos(r)*Math.cos(e);return(Math.atan2(o,c)*180/Math.PI+360)%360}export function isValidPointCoords(n){return typeof n=="number"&&Number.isFinite(n)}export function convertGpsToLocal({lat:n,lng:l,angle:t},s){if(!(isValidPointCoords(n)&&isValidPointCoords(l)))return null;let{p0:a,p2:r}=s;const e=u(a.lat,a.lng,r.lat,r.lng),o=bearing(a.lat,a.lng,r.lat,r.lng),c=h(a,r),i=y(a,r);let p=u(a.lat,a.lng,n,l),M=bearing(a.lat,a.lng,n,l)-o;if(!isValidPointCoords(e)||e<=0)return b.warn("Invalid GPS config: zero or negative distance",{fullGpsDistance:e,p0:a,p2:r}),null;let I=p/e,m=L(M,B(a,c*I,i),a.x,a.y),A=h(m,G(s.p0,s.p2)),D=h(s.p0,s.p2);return A>5*D?(b.warn("Current position too far"),null):{...m,angle:t}}export function convertLocalToGps(n,l,t){var s=-x(t.p0,t.p2,{x:t.p0.x+1e4,y:t.p0.y}),a=-x(t.p0,{x:n,y:l},{x:t.p0.x+1e4,y:t.p0.y}),r=a-s,e=h(t.p2,t.p0),o=h(t.p0,{x:n,y:l}),c=o/e,i=u(t.p0.lat,t.p0.lng,t.p2.lat,t.p2.lng),p=c*i,P=bearing(t.p0.lat,t.p0.lng,t.p2.lat,t.p2.lng),M=w(t.p0.lat,t.p0.lng,p,P+r);return M}function w(n,l,t,s){var a=t/g,r=v(s),e=v(n),o=v(l),c=Math.asin(Math.sin(e)*Math.cos(a)+Math.cos(e)*Math.sin(a)*Math.cos(r)),i=o+Math.atan2(Math.sin(r)*Math.sin(a)*Math.cos(e),Math.cos(a)-Math.sin(e)*Math.sin(c)),p=d(i);return(p<S||p>T)&&(i=(i+3*Math.PI)%(2*Math.PI)-Math.PI,p=d(i)),[p,d(c)]}export function calculateRelativeBearing(n){const l=R?.properties?.config?.bearing??0;return n?.angle===null?0:(((n.angle-l)%360+360)%360-90+360)%360}

package/dist/esm/utils/haversineDistance.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Great-circle distance between two GPS points using the Haversine formula.
+ *
+ * @returns distance in metres
+ */
+export declare function haversineDistance(lat1: number, lng1: number, lat2: number, lng2: number): number;
+//# sourceMappingURL=haversineDistance.d.ts.map

package/dist/esm/utils/haversineDistance.js

@@ -0,0 +1 @@
+export function haversineDistance(t,c,n,M){const o=t*Math.PI/180,i=n*Math.PI/180,s=(n-t)*Math.PI/180,a=(M-c)*Math.PI/180,h=Math.sin(s/2)*Math.sin(s/2)+Math.cos(o)*Math.cos(i)*Math.sin(a/2)*Math.sin(a/2);return 6371e3*(2*Math.atan2(Math.sqrt(h),Math.sqrt(1-h)))}

package/dist/esm/wayfinding/adapters/boothToEndpoint.d.ts

@@ -0,0 +1,13 @@
+import type { Booth } from "../../store/BoothStore";
+import type { RouteEndpoint } from "../core";
+/**
+ * Converts an efp `Booth` to a neutral {@link RouteEndpoint}.
+ *
+ * - Regular booth → `{x, y}` at rect centroid + `bounds` as a 4-vertex
+ *   polygon respecting the booth's rotation.
+ * - `RouteCutIn` (kiosk-like) → `{x, y}` at the kiosk's physical point
+ *   with **no `bounds`**. Runtime detects the missing `bounds` and draws a
+ *   dotted trail from the nearest graph anchor to this off-graph point.
+ */
+export declare function boothToEndpoint(booth: Booth): RouteEndpoint;
+//# sourceMappingURL=boothToEndpoint.d.ts.map

package/dist/esm/wayfinding/adapters/boothToEndpoint.js

@@ -0,0 +1 @@
+import n from"../../core/Polygon";function y(e){return e.entity?.type==="route-cut-in"}export function boothToEndpoint(e){if(y(e)){const t=e.destination;return{x:t.x,y:t.y,layer:e.layer?.name??""}}const r=n.fromRect(e.rect).rotate(e.rotate,e.rect.cx,e.rect.cy);return{x:e.rect.cx,y:e.rect.cy,layer:e.layer?.name??"",bounds:[{x:r.x1,y:r.y1},{x:r.x2,y:r.y2},{x:r.x3,y:r.y3},{x:r.x4,y:r.y4}]}}

package/dist/esm/wayfinding/adapters/boothToWaypoint.d.ts

@@ -1,5 +1,5 @@
 import type { Booth } from "../../store/BoothStore";
-import type { RouteWaypoint } from "../types";
+import type { RouteWaypoint } from "../core";
 /**
  * Converts a MobX Booth entity to a framework-free RouteWaypoint.
  *

package/dist/esm/wayfinding/adapters/canvasIconProvider.d.ts

@@ -0,0 +1,20 @@
+/**
+ * efp-app adapter: creates icon canvases from store.fp.icons.
+ *
+ * Extracts the icon creation block from config-wf.ts (lines 168–248).
+ * All canvases are pre-created eagerly.
+ * Fallback canvases are used when custom images are not available.
+ */
+import type { IconProvider } from "./iconProvider";
+interface CanvasIconProviderConfig {
+    /** Icon image map — typically store.fp.icons */
+    readonly iconMap: Map<string, HTMLImageElement>;
+    readonly pixelRatio: number;
+    /** Fallback color for source/current/transition icons (default: "#00A2FF") */
+    readonly sourceColor?: string;
+    /** Fallback color for destination icon (default: "#FF9F06") */
+    readonly destinationColor?: string;
+}
+export declare function createCanvasIconProvider(config: CanvasIconProviderConfig): IconProvider;
+export {};
+//# sourceMappingURL=canvasIconProvider.d.ts.map

package/dist/esm/wayfinding/adapters/canvasIconProvider.js

@@ -0,0 +1 @@
+import{createArrowCurrentCanvas as w,createCurrentCanvas as C,createImageCanvas as h,createTargetCanvas as g,createYahCanvas as v}from"../../components/Map/drawing/config/canvases";import{createCircleCanvas as F}from"../../renderer";import{decreaseByPercentage as _}from"../../utils/math";const I="#00A2FF",O="#FF9F06",e=34;function c(o,n,t,s,u,r){const i=o.get(n);return i?(i.id=n,h(i,t,s,u)):r()}function m(o,n,t,s,u){const r=o.get(n);return r?(r.id=n,h(r,t,s,u)):null}function a(o){return{canvas:o,width:o.width,height:o.height}}export function createCanvasIconProvider(o){const{iconMap:n,pixelRatio:t}=o,s=o.sourceColor??I,u=o.destinationColor??O,r=new Map;r.set("destination",a(c(n,"destination",e,e,t,()=>g(t,u)))),r.set("source",a(c(n,"departure",e,e,t,()=>C(t,s))));const i=C(t,s);i.id="current-location",r.set("current",a(i));const d=c(n,"transition",e,e,t,()=>C(t,s));r.set("transition",a(d)),r.set("transition_up",a(m(n,"transition_up",56,e,t)??d)),r.set("transition_down",a(m(n,"transition_down",56,e,t)??d)),r.set("transition_entry",a(c(n,"departure",e,e,t,()=>C(t,s)))),r.set("current_arrow",a(c(n,"direction",e,e,t,()=>w(t,s))));const f=c(n,"yah",_(64,32),_(90,32),t,()=>v(t,"#ff4343"));return f.id="current-location-2",r.set("yah",a(f)),r.set("trail",a(F(4,"#b5b7bc"))),{getIcon(l){const p=r.get(l);if(!p)throw new Error(`Unknown icon: ${l}`);return p}}}

package/dist/esm/wayfinding/adapters/floorContext.d.ts

@@ -0,0 +1,10 @@
+import type LayerStore from "../../store/LayerStore";
+import type RouteStore from "../../store/RouteStore";
+import type { FloorContext } from "../runtime/types";
+/**
+ * Adapter: builds a neutral {@link FloorContext} from the efp `LayerStore` +
+ * `RouteStore`. Single place in the code that knows about efp-specific magic
+ * values like `LayersMode.Default === 0`.
+ */
+export declare function createFloorContext(layerStore: LayerStore, routeStore: RouteStore): FloorContext;
+//# sourceMappingURL=floorContext.d.ts.map

package/dist/esm/wayfinding/adapters/floorContext.js

@@ -0,0 +1 @@
+const t=0;export function createFloorContext(r,s){return{showAllFloors(){return r.mode===0},getActiveFloor(){const e=s.currentRouteLayer?.name;return e&&r.layers.some(i=>i.name===e&&i.visible)?e:""},isLayerVisible(e){return e?r.findLayer?r.findLayer(e)?.visible??!0:r.layers.some(n=>n.name===e&&n.visible):!0},getFloorOrder(){return r.floors.map(e=>e.name).reverse()}}}

package/dist/esm/wayfinding/adapters/graphDataSource.d.ts

@@ -1,3 +1,3 @@
-import type { GraphDataSource } from "../types";
+import type { GraphDataSource } from "../core";
 export declare const graphDataSource: GraphDataSource;
 //# sourceMappingURL=graphDataSource.d.ts.map

package/dist/esm/wayfinding/adapters/iconProvider.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Port: icon asset provider.
+ *
+ * Abstracts away how icon canvases are created (custom image vs fallback).
+ */
+export type IconName = "source" | "destination" | "current" | "current_arrow" | "yah" | "transition" | "transition_up" | "transition_down" | "transition_entry" | "trail";
+export interface IconAsset {
+    readonly canvas: HTMLCanvasElement;
+    readonly width: number;
+    readonly height: number;
+}
+export interface IconProvider {
+    getIcon(name: IconName): IconAsset;
+}
+//# sourceMappingURL=iconProvider.d.ts.map

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

@@ -0,0 +1,9 @@
+export { boothToEndpoint } from "./boothToEndpoint";
+export { boothToWaypoint } from "./boothToWaypoint";
+export { createCanvasIconProvider } from "./canvasIconProvider";
+export { createFloorContext } from "./floorContext";
+export { graphDataSource } from "./graphDataSource";
+export { createKioskCanvas } from "./kioskCanvas";
+export { positionInput } from "./positionInput";
+export type { IconAsset, IconName, IconProvider } from "./iconProvider";
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/wayfinding/adapters/index.js

@@ -0,0 +1 @@
+export{boothToEndpoint}from"./boothToEndpoint";export{boothToWaypoint}from"./boothToWaypoint";export{createCanvasIconProvider}from"./canvasIconProvider";export{createFloorContext}from"./floorContext";export{graphDataSource}from"./graphDataSource";export{createKioskCanvas}from"./kioskCanvas";export{positionInput}from"./positionInput";

package/dist/esm/wayfinding/adapters/kioskCanvas.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Builds the kiosk icon canvas. If `kioskIconMap` provides a "kiosk" image,
+ * it's drawn at a size scaled by `iconSizePercent` (default 100%). Otherwise
+ * falls back to a generic arrow canvas tinted with the fallback color.
+ */
+export declare function createKioskCanvas(kioskIconMap: Map<string, HTMLImageElement> | undefined, iconSizePercent?: number): HTMLCanvasElement;
+//# sourceMappingURL=kioskCanvas.d.ts.map

package/dist/esm/wayfinding/adapters/kioskCanvas.js

@@ -0,0 +1 @@
+import c from"color";import{createImageCanvas as s,createArrowCurrentCanvas as K}from"../../components/Map/drawing/config/canvases";import{decreaseByPercentage as a}from"../../utils/math";const C=199,_=152,i=55,m="#ee4422";export function createKioskCanvas(n,o){const t=devicePixelRatio,e=n?.get("kiosk");if(e){e.id="kiosk";const r=o?o/100:1;return s(e,a(C*r,i),a(_*r,i),t)}return K(t,c(m).hex())}

package/dist/esm/wayfinding/adapters/positionInput.d.ts

@@ -0,0 +1,11 @@
+import type { CurrentPosition } from "../../store/RouteStore";
+import type { PositionInput } from "../runtime/types";
+/**
+ * Converts the efp `CurrentPosition` class instance to a neutral
+ * `PositionInput` for the runtime.
+ *
+ * `z` in CurrentPosition can be `number | string | undefined`; the runtime
+ * expects `layer: string`. Non-finite `angle` becomes `undefined`.
+ */
+export declare function positionInput(position: CurrentPosition): PositionInput;
+//# sourceMappingURL=positionInput.d.ts.map

package/dist/esm/wayfinding/adapters/positionInput.js

@@ -0,0 +1 @@
+export function positionInput(e){return{x:e.x,y:e.y,layer:e.z!=null?String(e.z):"",angle:Number.isFinite(e.angle)?e.angle:void 0}}

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

@@ -0,0 +1,27 @@
+import type LayerStore from "../store/LayerStore";
+import type RouteStore from "../store/RouteStore";
+import type UIState from "../store/UIState";
+import type { KioskHandler } from "./handlers/kioskHandler";
+import type { YahHandler } from "./handlers/yahHandler";
+import type { WayfindingRuntime } from "./runtime/types";
+interface BindMobxReactionsArgs {
+    readonly runtime: WayfindingRuntime;
+    readonly kioskHandler: KioskHandler;
+    readonly yahHandler: YahHandler;
+    readonly stores: {
+        readonly routeStore: RouteStore;
+        readonly uiState: UIState;
+        readonly layerStore: LayerStore;
+    };
+}
+/**
+ * Wires the observable efp stores to the imperative wayfinding runtime and
+ * the efp-side kiosk/yah handlers. Each reaction translates observable
+ * changes into neutral-typed imperative calls.
+ *
+ * Returns a dispose function that tears down all reactions plus the deferred
+ * floor-change timeout.
+ */
+export declare function bindMobxReactions({ runtime, kioskHandler, yahHandler, stores: { routeStore, uiState, layerStore }, }: BindMobxReactionsArgs): () => void;
+export {};
+//# sourceMappingURL=bindMobxReactions.d.ts.map

package/dist/esm/wayfinding/bindMobxReactions.js

@@ -0,0 +1 @@
+import{reaction as f}from"mobx";import{boothToEndpoint as a,positionInput as g}from"./adapters";export function bindMobxReactions({runtime:s,kioskHandler:h,yahHandler:d,stores:{routeStore:e,uiState:n,layerStore:l}}){const p=[];function r(){const o=n.selectedRoute?.from,i=n.selectedRoute?.to;if(!o?.rect||!i?.rect){s.clearRoute();return}s.setRoute({from:a(o),to:a(i),waypoints:n.selectedRoute?.waypoints?.map(a),accessible:e.onlyAccessible})}function c(){const o=e.currentPosition,i=e.iconType!==0,y=!!(n.selectedRoute?.from&&n.selectedRoute?.to),b=i&&!y;if(!o){s.onPositionChanged(null),d(null);return}const u=g(o);b?(s.onPositionChanged(null),d({x:u.x,y:u.y,layer:u.layer})):(d(null),s.onPositionChanged(u))}function R(){const o=l.floors.find(i=>i.active)?.name;h(n.kioskData??null,o,l.mode)}p.push(f(()=>l.layersLoaded,()=>{r(),c()}),f(()=>[n.selectedRoute,e.onlyAccessible],()=>{r(),c()}),f(()=>e.currentPosition,()=>c()),f(()=>[n.kioskData,l.floors.find(o=>o.active)],()=>R()));let t=null;const m=f(()=>[e.currentRouteLayer,n.getRouteNextFloor],()=>{l.layersLoaded&&(t!==null&&clearTimeout(t),t=setTimeout(()=>{s.onFloorChanged(),c(),t=null},0))});return p.push(()=>{t!==null&&clearTimeout(t),m()}),r(),c(),R(),()=>{for(const o of p)o();p.length=0}}

package/dist/esm/wayfinding/{__tests__ → core/__tests__}/helpers.d.ts

@@ -1,10 +1,5 @@
 import type { GraphBuildOptions, GraphDataSource, GraphInstance, PathNode, RouteLine, RoutePoint } from "../types";
 export declare function makePoint(layer: string, x: number, y: number): RoutePoint;
-/** Creates a simple linear graph: p0 — p1 — p2 — ... */
-export declare function makeLinearGraph(layerName: string, ...coords: [number, number][]): {
-    points: RoutePoint[];
-    lines: RouteLine[];
-};
 export declare function makeLine(p0: RoutePoint, p1: RoutePoint, overrides?: Partial<Omit<RouteLine, "p0" | "p1">>): RouteLine;
 export declare function makeNode(layer: string, x: number, y: number): PathNode;
 export declare function createMockDataSource(options?: {

package/dist/esm/wayfinding/core/__tests__/helpers.js

@@ -0,0 +1 @@
+import{vi as i}from"vitest";export function makePoint(e,n,t){return{layer:e,x:n,y:t}}export function makeLine(e,n,t={}){return{p0:e,p1:n,unaccessible:!1,unidirection:!1,virtual:!1,weight:4,...t}}export function makeNode(e,n,t){return{id:`${e}_${n}_${t}`,layer:e,x:n,y:t}}export function createMockDataSource(e={}){return{getLines:()=>e.lines??[],getLineEnds:()=>e.lineEnds??[]}}export function createMockGraph(e={}){const{lines:n=[],lineEnds:t=[],hasNodeResult:o=!0,findResult:r=[],graphOptions:u}=e;return{finder:{build:i.fn(),hasNode:typeof o=="function"?i.fn(o):i.fn().mockReturnValue(o),find:typeof r=="function"?i.fn(r):i.fn().mockReturnValue(r)},dataSource:{getLines:()=>n,getLineEnds:()=>t},options:u??{oriented:!0}}}

package/dist/esm/wayfinding/core/createWayfindingEngine.d.ts

@@ -0,0 +1,16 @@
+import type { GraphDataSource, RouteLine, RouteWaypoint } from "./types";
+export interface Route {
+    readonly lines: RouteLine[];
+    readonly distance: number;
+}
+export interface WayfindingEngine {
+    buildRoute(from: RouteWaypoint, to: RouteWaypoint, options?: {
+        accessible?: boolean;
+    }): Route;
+    buildWaypointsRoute(waypoints: RouteWaypoint[], options?: {
+        accessible?: boolean;
+        fastest?: boolean;
+    }): Route;
+}
+export declare function createWayfindingEngine(dataSource: GraphDataSource): WayfindingEngine;
+//# sourceMappingURL=createWayfindingEngine.d.ts.map

package/dist/esm/wayfinding/core/createWayfindingEngine.js

@@ -0,0 +1 @@
+import{createGraphCache as d}from"./graph/graphCache";import{buildRoute as u}from"./routing/buildRoute";import{buildMultiPointRoute as f}from"./routing/buildMultiPointRoute";import{resolveWaypointCandidates as a}from"./routing/resolveWaypointCandidates";import{reorderWaypoints as m}from"./routing/optimizeWaypointOrder";export function createWayfindingEngine(c){const l=d();return{buildRoute(e,t,r){const n=l.getOrBuild(c,r?.accessible??!1),s=a(n,e),i=a(n,t),o=u(n,s,i);return{lines:o.lines,distance:o.totalDistance}},buildWaypointsRoute(e,t){if(e.length<2)return{lines:[],distance:0};const r=l.getOrBuild(c,t?.accessible??!1),s=(t?.fastest?m(e):e).map(o=>a(r,o)),i=f(r,s);return{lines:i.lines,distance:i.totalDistance}}}}

package/dist/esm/wayfinding/{graph → core/graph}/graphCache.d.ts

@@ -1,6 +1,7 @@
 import type { GraphDataSource, GraphInstance } from "../types";
-export interface GraphCache {
+interface GraphCache {
     getOrBuild(dataSource: GraphDataSource, onlyAccessible: boolean): GraphInstance;
 }
 export declare function createGraphCache(): GraphCache;
+export {};
 //# sourceMappingURL=graphCache.d.ts.map

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

@@ -0,0 +1,16 @@
+export { createWayfindingEngine } from "./createWayfindingEngine";
+export type { WayfindingEngine, Route } from "./createWayfindingEngine";
+export type { GraphDataSource, PositionPoint, RouteEndpoint, RouteLine, RoutePoint, RouteSnapResult, RouteWaypoint, SnapToRouteConfig, } from "./types";
+export { computeTransitionPoints } from "./rendering/computeTransitionPoints";
+export type { TransitionPointDef } from "./rendering/computeTransitionPoints";
+export { computeTrailPoints } from "./rendering/computeTrailPoints";
+export { getVisibleRouteLines } from "./rendering/getVisibleRouteLines";
+export { computeBoundingBox } from "./rendering/routeGeometry";
+export type { BoundingBox } from "./rendering/routeGeometry";
+export { normalizeRouteDirection } from "./rendering/normalizeRouteDirection";
+export { getRouteLength } from "./routing/getRouteLength";
+export { SNAP_THRESHOLD_METERS, getThresholdSafe, getThresholdFromMetersToSvg } from "./position/gpsThreshold";
+export { shouldReroute } from "./position/shouldReroute";
+export { snapToRoute } from "./position/snapToRoute";
+export { splitRouteByPoint } from "./position/splitRouteByPoint";
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/wayfinding/core/index.js

@@ -0,0 +1 @@
+export{createWayfindingEngine}from"./createWayfindingEngine";export{computeTransitionPoints}from"./rendering/computeTransitionPoints";export{computeTrailPoints}from"./rendering/computeTrailPoints";export{getVisibleRouteLines}from"./rendering/getVisibleRouteLines";export{computeBoundingBox}from"./rendering/routeGeometry";export{normalizeRouteDirection}from"./rendering/normalizeRouteDirection";export{getRouteLength}from"./routing/getRouteLength";export{SNAP_THRESHOLD_METERS,getThresholdSafe,getThresholdFromMetersToSvg}from"./position/gpsThreshold";export{shouldReroute}from"./position/shouldReroute";export{snapToRoute}from"./position/snapToRoute";export{splitRouteByPoint}from"./position/splitRouteByPoint";

package/dist/esm/wayfinding/core/position/distanceToRoute.d.ts

@@ -0,0 +1,3 @@
+import type { RouteLine, RoutePoint } from "../types";
+export declare function distancePointToRouteOnLayer(point: RoutePoint, lines: RouteLine[]): number;
+//# sourceMappingURL=distanceToRoute.d.ts.map

package/dist/esm/wayfinding/core/position/distanceToRoute.js

@@ -0,0 +1 @@
+function h(n,c,e,t,r,y){const s=r-e,i=y-t,a=n-e,l=c-t,f=s*s+i*i;if(f===0)return Math.hypot(n-e,c-t);let o=(a*s+l*i)/f;o<0?o=0:o>1&&(o=1);const u=e+o*s,b=t+o*i;return Math.hypot(n-u,c-b)}export function distancePointToRouteOnLayer(n,c){let e=1/0;for(const t of c){if(n.layer&&(t.p0.layer!==n.layer||t.p1.layer!==n.layer))continue;const r=h(n.x,n.y,t.p0.x,t.p0.y,t.p1.x,t.p1.y);r<e&&(e=r)}return e}

package/dist/esm/wayfinding/core/position/gpsThreshold.d.ts

@@ -0,0 +1,22 @@
+export declare const SNAP_THRESHOLD_METERS = 7.5;
+type GpsProjectionConfig = {
+    p0: {
+        x: number;
+        y: number;
+        lat: number;
+        lng: number;
+    };
+    p2: {
+        x: number;
+        y: number;
+        lat: number;
+        lng: number;
+    };
+};
+export declare const getThresholdSafe: (value: number) => number | undefined;
+export declare function getThresholdFromMetersToSvg({ thresholdInMeters, gpsConfig }: {
+    thresholdInMeters?: number;
+    gpsConfig?: GpsProjectionConfig;
+}): number;
+export {};
+//# sourceMappingURL=gpsThreshold.d.ts.map

package/dist/esm/wayfinding/core/position/gpsThreshold.js

@@ -0,0 +1 @@
+import{lineLength as s}from"simple-geometry";import{haversineDistance as f}from"../../../utils/haversineDistance";export const SNAP_THRESHOLD_METERS=7.5;const c=20;function l(t,n){const{p0:e,p2:r}=n,o=f(e.lat,e.lng,r.lat,r.lng),i=s(e,r);return!o||!i?0:t*(i/o)}export const getThresholdSafe=t=>{if(typeof t=="number"&&Number.isFinite(t))return t};export function getThresholdFromMetersToSvg({thresholdInMeters:t,gpsConfig:n}){let e=0;return t&&n&&(e=l(t,n)),e||(e=c),e}

package/dist/esm/wayfinding/core/position/shouldReroute.d.ts

@@ -0,0 +1,3 @@
+import type { PositionPoint, RouteLine } from "../types";
+export declare function shouldReroute(position: PositionPoint | null, routeLines: RouteLine[], threshold?: number): boolean;
+//# sourceMappingURL=shouldReroute.d.ts.map

package/dist/esm/wayfinding/core/position/shouldReroute.js

@@ -0,0 +1 @@
+import{distancePointToRouteOnLayer as u}from"./distanceToRoute";const c=10;export function shouldReroute(t,e,r=c){if(!t||!e.length)return!1;const l={layer:t.z!=null?String(t.z):"",x:t.x,y:t.y},n=u(l,e);return isFinite(n)&&n>r}

package/dist/esm/wayfinding/core/position/snapToRoute.d.ts

@@ -0,0 +1,4 @@
+import type { PositionPoint, RouteLine, RouteSnapResult, SnapToRouteConfig } from "../types";
+export { SNAP_THRESHOLD_METERS } from "./gpsThreshold";
+export declare function snapToRoute(position: PositionPoint, routeLines: RouteLine[], config: SnapToRouteConfig): RouteSnapResult;
+//# sourceMappingURL=snapToRoute.d.ts.map

package/dist/esm/wayfinding/core/position/snapToRoute.js

@@ -0,0 +1 @@
+const H=1e-9;function w(s,i,t,a){const n=(s-t.x)*(a.y-t.y)-(i-t.y)*(a.x-t.x);if(Math.abs(n)>H)return!1;const e=(s-t.x)*(a.x-t.x)+(i-t.y)*(a.y-t.y),c=(a.x-t.x)**2+(a.y-t.y)**2;return e>=0&&e<=c}function q(s,i,t){if(t.length<3)return!1;for(let n=0,e=t.length-1;n<t.length;e=n++)if(w(s,i,t[e],t[n]))return!0;let a=!1;for(let n=0,e=t.length-1;n<t.length;e=n++){const c=t[n].x,d=t[n].y,r=t[e].x,y=t[e].y;d>i!=y>i&&s<(r-c)*(i-d)/(y-d)+c&&(a=!a)}return a}function F(s,i){let t=0;for(const n of s){const e=Math.hypot(n.p1.x-n.p0.x,n.p1.y-n.p0.y);if(e!==0){if(t+e>=i){const c=(i-t)/e,d=n.p0.x+(n.p1.x-n.p0.x)*c,r=n.p0.y+(n.p1.y-n.p0.y)*c;return{point:{layer:n.p0.layer,x:d,y:r},line:n}}t+=e}}const a=s[s.length-1];return{point:{layer:a.p0.layer,x:a.p1.x,y:a.p1.y},line:a}}export{SNAP_THRESHOLD_METERS}from"./gpsThreshold";export function snapToRoute(s,i,t){const a=i.length;if(!a)return{snapped:!1};const{snapThreshold:n,to:e,from:c,minRemainingUnits:d=.5}=t,r=s.z!=null?String(s.z):null;let y=1/0,f=null,m=0,R=r==null;for(let o=0;o<a;o++){const x=i[o],{p0:l,p1:h}=x,g=h.x-l.x,P=h.y-l.y,T=g*g+P*P;if(T===0)continue;const E=Math.sqrt(T);if(r!=null&&String(l.layer)!==r){m+=E;continue}R=!0;const b=((s.x-l.x)*g+(s.y-l.y)*P)/T,M=Math.max(0,Math.min(1,b)),v=l.x+g*M,z=l.y+P*M,_=Math.hypot(s.x-v,s.y-z);_<y&&(y=_,f={segmentIndex:o,t:M,distanceFromPolylineStart:m+E*M}),m+=E}if(r!=null&&!R)return{snapped:!1};const p=m,O=i[0].p0,j=i[a-1].p1,A=Math.hypot(e.x-O.x,e.y-O.y),L=Math.hypot(e.x-j.x,e.y-j.y),S=A<=L,D=Math.min(d,p);if(c?.bounds&&(r==null||!c.layer||c.layer===r)&&q(s.x,s.y,c.bounds)){const o=p,x=S?o:p-o,l=F(i,x);return{snapped:!0,snappedPoint:l.point,snappedLine:l.line,distance:o}}if(e.bounds&&(r==null||!e.layer||e.layer===r)&&q(s.x,s.y,e.bounds)){const o=D,x=p-o,h=F(i,S?o:x);return{snapped:!0,snappedPoint:h.point,snappedLine:h.line,distance:o}}if(!f||y>n)return{snapped:!1};let u=S?f.distanceFromPolylineStart:p-f.distanceFromPolylineStart;u<D&&(u=D);const N=p-u,I=F(i,S?u:N);return{snapped:!0,snappedPoint:I.point,snappedLine:I.line,distance:u}}

package/dist/esm/{components/Map/drawing/config/route-snapping → wayfinding/core/position}/splitRouteByPoint.d.ts

@@ -1,4 +1,4 @@
-import type { RouteLine, RoutePoint } from "../../../../../wayfinding/types";
+import type { RouteLine, RoutePoint } from "../types";
 export declare function splitRouteByPoint(routeLines: RouteLine[], snapPoint: RoutePoint): {
     passed: RouteLine[];
     remaining: RouteLine[];

package/dist/esm/wayfinding/core/position/splitRouteByPoint.js

@@ -0,0 +1 @@
+export function splitRouteByPoint(t,c){let n=-1,e=0,f=1/0;for(let l=0;l<t.length;l++){const p=t[l];if(p.p0.layer!==c.layer)continue;const s=p.p1.x-p.p0.x,y=p.p1.y-p.p0.y,r=s*s+y*y;if(r===0)continue;const x=((c.x-p.p0.x)*s+(c.y-p.p0.y)*y)/r;if(x<-1e-6||x>1+1e-6)continue;const a=Math.min(1,Math.max(0,x)),m=p.p0.x+a*s,g=p.p0.y+a*y,o=(c.x-m)**2+(c.y-g)**2;o<f&&(f=o,n=l,e=a)}if(n===-1)return{passed:[],remaining:t};if(e<1e-6)return{passed:t.slice(0,n),remaining:t.slice(n)};if(e>1-1e-6)return{passed:t.slice(0,n+1),remaining:t.slice(n+1)};const i=t[n],d={layer:i.p0.layer,x:i.p0.x+e*(i.p1.x-i.p0.x),y:i.p0.y+e*(i.p1.y-i.p0.y)};return{passed:[...t.slice(0,n),{...i,p1:d}],remaining:[{...i,p0:d},...t.slice(n+1)]}}

package/dist/esm/wayfinding/core/rendering/computeTrailPoints.d.ts

@@ -0,0 +1,19 @@
+import type { Point } from "simple-geometry";
+/**
+ * Generates evenly-spaced points along a quadratic Bézier curve
+ * between two points. Used for dotted trail visualization when
+ * a point (kiosk, GPS, marker, etc.) is far from the route.
+ *
+ * @param from - Start point (e.g. route endpoint)
+ * @param to - End point (e.g. off-route position)
+ * @param interval - Spacing between points in SVG units (default: 8)
+ * @param curvature - Arc height as fraction of distance (0 = straight, 0.4 = default arc)
+ */
+export declare function computeTrailPoints(from: {
+    x: number;
+    y: number;
+}, to: {
+    x: number;
+    y: number;
+}, interval?: number, curvature?: number): Point[];
+//# sourceMappingURL=computeTrailPoints.d.ts.map

package/dist/esm/wayfinding/core/rendering/computeTrailPoints.js

@@ -0,0 +1 @@
+const A=.4,E=8;export function computeTrailPoints(c,s,i=8,t=.4){const n=Math.hypot(s.x-c.x,s.y-c.y);if(n===0||i<=0)return[];const y=Math.max(Math.ceil(n/i)+1,2),o={x:(c.x+s.x)/2,y:(c.y+s.y)/2-n*t},e=[];for(let x=0;x<y;x++){const u=x/(y-1);e.push(T(c,o,s,u))}return e}function T(c,s,i,t){const n=1-t;return{x:n*n*c.x+2*n*t*s.x+t*t*i.x,y:n*n*c.y+2*n*t*s.y+t*t*i.y}}

package/dist/esm/wayfinding/{rendering → core/rendering}/computeTransitionPoints.d.ts

@@ -2,12 +2,12 @@ import type { RouteLine } from "../types";
 interface TransitionPointsInput {
     /** Full route including virtual lines */
     readonly routeLines: RouteLine[];
-    /** Current floor name (null = single-floor) */
+    /** Floor to scope to. `null` = no floor scoping (returns transitions on every floor). */
     readonly currentLayerName: string | null;
     /** Floor names ordered low → high (from layerStore.floors) */
     readonly floorOrder: string[];
 }
-interface TransitionPointDef {
+export interface TransitionPointDef {
     readonly x: number;
     readonly y: number;
     /** Floor where the icon is rendered */

package/dist/esm/wayfinding/core/rendering/getVisibleRouteLines.d.ts

@@ -0,0 +1,11 @@
+import type { RouteLine } from "../types";
+/**
+ * Filters route lines for a given floor: removes virtual segments
+ * and keeps only lines on the specified floor.
+ *
+ * @param routeLines - All route lines (may span multiple floors)
+ * @param currentFloor - Floor to filter by, or `null` to return all non-virtual lines
+ *   (single-floor plans / "show all" mode)
+ */
+export declare function getVisibleRouteLines(routeLines: ReadonlyArray<RouteLine>, currentFloor: string | null): RouteLine[];
+//# sourceMappingURL=getVisibleRouteLines.d.ts.map

package/dist/esm/wayfinding/core/rendering/getVisibleRouteLines.js

@@ -0,0 +1 @@
+export function getVisibleRouteLines(t,e){const i=[];for(const n of t)n.virtual||e!==null&&n.p0.layer!==e||i.push(n);return i}

package/dist/esm/wayfinding/core/rendering/normalizeRouteDirection.d.ts

@@ -0,0 +1,20 @@
+import type { RouteLine, RoutePoint } from "../types";
+/**
+ * Ensures that `routeLines` run in the from→to direction.
+ *
+ * A* returns paths in target→source order. For rendering (arrow animation,
+ * route progress split) and remaining-distance computation the lines must
+ * go from the origin to the destination.
+ *
+ * Direction is decided by projecting `from` (or `to` as a fallback) onto
+ * `routeLines`: if the anchor lands closer to the polyline end than to
+ * its start, the array is reversed and each segment's endpoints are
+ * flipped to keep continuity.
+ *
+ * @param routeLines  Lines to normalize.
+ * @param from        Route origin (user-selected "from" point).
+ * @param to          Route destination (user-selected "to" point).
+ * @returns Lines guaranteed to run from→to, or the original array unchanged.
+ */
+export declare function normalizeRouteDirection(routeLines: RouteLine[], from: RoutePoint, to: RoutePoint): RouteLine[];
+//# sourceMappingURL=normalizeRouteDirection.d.ts.map

package/dist/esm/wayfinding/core/rendering/normalizeRouteDirection.js

@@ -0,0 +1 @@
+function i(t,s,p){let r=0,a=1/0,c=1/0;const f=p.reduce((e,n)=>e+n,0);for(let e=0;e<s.length;e++){const n=s[e],o=p[e];if(t.layer&&n.p0.layer!==t.layer){r+=o;continue}const d=n.p1.x-n.p0.x,y=n.p1.y-n.p0.y,h=d*d+y*y;if(h<1e-10){r+=o;continue}const l=((t.x-n.p0.x)*d+(t.y-n.p0.y)*y)/h,u=Math.max(0,Math.min(1,l)),x=n.p0.x+d*u,S=n.p0.y+y*u,m=Math.hypot(t.x-x,t.y-S);m<a&&(a=m,c=r+o*u),r+=o}return{found:c!==1/0,fromStart:c,total:f}}export function normalizeRouteDirection(t,s,p){const r=t.map(o=>Math.hypot(o.p1.x-o.p0.x,o.p1.y-o.p0.y)),a=i(s,t,r),c=a.found?a:i(p,t,r);if(!c.found)return t;const f=c.fromStart,e=c.total-c.fromStart;return(a.found?e<f:f<e)?t.slice().reverse().map(o=>({...o,p0:o.p1,p1:o.p0})):t}

package/dist/esm/wayfinding/core/rendering/routeGeometry.d.ts

@@ -0,0 +1,15 @@
+export interface BoundingBox {
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+}
+/**
+ * Computes the axis-aligned bounding box of a set of points.
+ * Returns null for an empty array.
+ */
+export declare function computeBoundingBox(points: ReadonlyArray<{
+    x: number;
+    y: number;
+}>): BoundingBox | null;
+//# sourceMappingURL=routeGeometry.d.ts.map

package/dist/esm/wayfinding/core/rendering/routeGeometry.js

@@ -0,0 +1 @@
+export function computeBoundingBox(e){if(e.length===0)return null;let i=1/0,t=1/0,f=-1/0,y=-1/0;for(const n of e)n.x<i&&(i=n.x),n.y<t&&(t=n.y),n.x>f&&(f=n.x),n.y>y&&(y=n.y);return{x1:i,y1:t,x2:f,y2:y}}

package/dist/esm/wayfinding/core/routing/optimizeWaypointOrder.d.ts

@@ -0,0 +1,19 @@
+type Point = {
+    cx: number;
+    cy: number;
+};
+/**
+ * Optimizes waypoint ordering to minimize total travel distance.
+ * Nearest neighbor O(n²) + 2-opt refinement O(k·n²), k ≤ 100.
+ */
+export declare function optimizeWaypointOrder(data: [string, Point][]): string[];
+/**
+ * Reorders waypoints for fastest traversal.
+ * First and last stay fixed (from/to), only middle waypoints are reordered.
+ */
+export declare function reorderWaypoints<T extends {
+    x: number;
+    y: number;
+}>(waypoints: T[]): T[];
+export {};
+//# sourceMappingURL=optimizeWaypointOrder.d.ts.map

package/dist/esm/wayfinding/core/routing/optimizeWaypointOrder.js

@@ -0,0 +1 @@
+const x=100,b=-.01;export function optimizeWaypointOrder(e){const c=new Map(e),t=Array.from(c.keys());if(t.length<=2)return t;const r=M(t,c);return r.length<4?r:u(r,c)}export function reorderWaypoints(e){if(e.length<=3)return e;const c=e[0],t=e[e.length-1],r=e.slice(1,-1),i=r.map((o,a)=>[String(a),{cx:o.x,cy:o.y}]),n=optimizeWaypointOrder(i).map(o=>r[Number(o)]);return[c,...n,t]}function M(e,c){const t=[e[0]],r=new Set(e);let i=e[0];for(r.delete(e[0]);r.size>0;){const s=c.get(i);let n="",o=1/0;for(const a of r){const l=c.get(a),d=Math.abs(s.cx-l.cx)+Math.abs(s.cy-l.cy);d<o&&(o=d,n=a)}if(!n)break;t.push(n),r.delete(n),i=n}return t}function u(e,c){const t=[...e];let r=!0;for(let i=0;r&&i<100;i++){r=!1;t:for(let s=1;s<t.length-2;s++)for(let n=s+1;n<t.length-1;n++){const o=c.get(t[s-1]),a=c.get(t[s]),l=c.get(t[n]),d=c.get(t[n+1]);if(Math.abs(o.cx-l.cx)+Math.abs(o.cy-l.cy)+Math.abs(a.cx-d.cx)+Math.abs(a.cy-d.cy)-(Math.abs(o.cx-a.cx)+Math.abs(o.cy-a.cy))-(Math.abs(l.cx-d.cx)+Math.abs(l.cy-d.cy))<-.01){for(let f=s,h=n;f<h;f++,h--)[t[f],t[h]]=[t[h],t[f]];r=!0;break t}}}return t}

package/dist/esm/wayfinding/core/routing/resolveWaypointCandidates.d.ts

@@ -0,0 +1,7 @@
+import type { GraphInstance, RoutePoint, RouteWaypoint } from "../types";
+/**
+ * Resolves a waypoint to candidate graph points.
+ * Uses rect-based search if the waypoint has a rect, otherwise falls back to nearest-point lookup.
+ */
+export declare function resolveWaypointCandidates(graph: GraphInstance, waypoint: RouteWaypoint): RoutePoint[];
+//# sourceMappingURL=resolveWaypointCandidates.d.ts.map

package/dist/esm/wayfinding/core/routing/resolveWaypointCandidates.js

@@ -0,0 +1 @@
+import{findGraphPointsInRect as n,findNearestGraphPoint as a}from"./findNearestGraphPoint";export function resolveWaypointCandidates(r,e){if(e.rect)return n(r.dataSource,e.rect,e.layer);const t=a(r,{x:e.x,y:e.y,layer:e.layer});return t?[t]:[]}

package/dist/esm/wayfinding/{types.d.ts → core/types.d.ts}

@@ -73,4 +73,41 @@ export interface RouteWaypoint {
      */
     readonly rect?: SimpleGeometryRect;
 }
+/** Minimal position interface — replaces CurrentPosition class dependency in core. */
+export interface PositionPoint {
+    readonly x: number;
+    readonly y: number;
+    readonly z?: string | number | null;
+}
+export type RouteSnapResult = {
+    snapped: false;
+} | {
+    snapped: true;
+    snappedPoint: RoutePoint;
+    snappedLine: RouteLine;
+    /** Arc-length from `snappedPoint` to the destination, along the route. */
+    distance: number;
+};
+/**
+ * An endpoint of a route — anchor coordinates on a layer, optionally with a
+ * polygon describing the surrounding region (for booths and similar areas).
+ * Absence of `bounds` means the endpoint is a single off-graph point (e.g.
+ * a kiosk) and the runtime will draw a dotted trail to the nearest graph
+ * anchor.
+ */
+export interface RouteEndpoint {
+    readonly x: number;
+    readonly y: number;
+    readonly layer: string;
+    readonly bounds?: ReadonlyArray<{
+        readonly x: number;
+        readonly y: number;
+    }>;
+}
+export type SnapToRouteConfig = {
+    snapThreshold: number;
+    minRemainingUnits?: number;
+    to: RouteEndpoint;
+    from?: RouteEndpoint;
+};
 //# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1,3 @@
+import type { RendererService } from "../renderer";
+export declare function createWayfinding(rendererService: RendererService): () => void;
+//# sourceMappingURL=createWayfinding.d.ts.map

package/dist/esm/wayfinding/createWayfinding.js

@@ -0,0 +1 @@
+import _ from"../core/Rect";import{fpGeo as p}from"../data/fpGeo";import t,{layersStore as n,uiState as f}from"../store";import{createCanvasIconProvider as A,createFloorContext as u,graphDataSource as x}from"./adapters";import{bindMobxReactions as T}from"./bindMobxReactions";import{createWayfindingEngine as M,getThresholdSafe as L,getThresholdFromMetersToSvg as N,SNAP_THRESHOLD_METERS as I}from"./core";import{createKioskHandler as W}from"./handlers/kioskHandler";import{createYahHandler as k}from"./handlers/yahHandler";import{WF_LINES_ANIMATED_LAYER_NAME as v,WF_LINES_LAYER_NAME as F,WF_POINTS_LAYER_NAME as H,WF_TRAIL_LAYER_NAME as P}from"./layers";import{createWayfindingRuntime as C}from"./runtime/createWayfindingRuntime";import{createWayfindingRenderer as D}from"./renderer";export function createWayfinding(m){const l=M(x),a=A({iconMap:t.fp.icons,pixelRatio:devicePixelRatio}),r=D(m),s=u(n,t.routeStore),i={points:H,trail:P,lines:F,linesAnimated:v},d=L(p?.properties?.config?.snapThreshold)||I,y=N({thresholdInMeters:d,gpsConfig:p?.properties?.config}),c=C({engine:l,renderer:r,iconProvider:a,floorContext:s,layers:i,snapThreshold:y,onTransitionClick:o=>{o.role==="exit"&&n.updateVisibility(o.targetLayer,!0)},onRouteUpdate:(o,e)=>{if(t.routeStore.updateRoute(o),e){const S=e.x2-e.x1,E=e.y2-e.y1;f.moveToRect=_.fromX1y1x2y2(e.x1,e.y1,e.x2,e.y2).withPadding(S,E)}},onRouteDistance:o=>t.routeStore.updateRouteDistance(o)}),R=W({renderer:r,kioskIconMap:t.fp.icons,layer:i.points}),g=k({renderer:r,iconProvider:a,floorContext:s,layer:i.points}),h=T({runtime:c,kioskHandler:R,yahHandler:g,stores:{routeStore:t.routeStore,uiState:f,layerStore:n}});return r.flush(),()=>{h(),c.destroy()}}

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

@@ -0,0 +1,25 @@
+import type { Kiosk } from "../../components/Kiosk/SetKiosk";
+import type { WayfindingRenderer } from "../renderer";
+/**
+ * Updates the kiosk icon in response to store changes.
+ *
+ * @param kiosk         Current kiosk data, or null when kiosk mode is off.
+ * @param activeFloor   Name of the currently active floor (from `layerStore.floors.find(f => f.active)`), or undefined.
+ * @param layersMode    Current `layerStore.mode` value; when equal to `LayersMode.Default` (0),
+ *                      the per-floor visibility check is skipped.
+ */
+export type KioskHandler = (kiosk: Kiosk | null, activeFloor: string | undefined, layersMode: number) => 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.
+ */
+export declare function createKioskHandler({ renderer, kioskIconMap, layer, }: {
+    renderer: WayfindingRenderer;
+    kioskIconMap: Map<string, HTMLImageElement> | undefined;
+    layer: string;
+}): KioskHandler;
+//# sourceMappingURL=kioskHandler.d.ts.map

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

@@ -0,0 +1 @@
+import{createKioskCanvas as u}from"../adapters";const o="kiosk",s=0;export function createKioskHandler({renderer:n,kioskIconMap:a,layer:f}){return(t,c,l)=>{if(!t){n.setIcon(o,null),n.flush();return}if(l!==s&&t.z&&c&&t.z!==c){n.setIcon(o,null),n.flush();return}n.setIcon(o,{canvas:u(a,t.iconSizePercent),layer:f,x:t.x,y:t.y,rotation:(t.heading??0)*Math.PI/180}),n.flush()}}

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

@@ -0,0 +1,23 @@
+import type { IconProvider } from "../adapters";
+import type { WayfindingRenderer } from "../renderer";
+import type { FloorContext } from "../runtime/types";
+/**
+ * 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({ renderer, iconProvider, floorContext, layer, }: {
+    renderer: WayfindingRenderer;
+    iconProvider: IconProvider;
+    floorContext: FloorContext;
+    layer: string;
+}): YahHandler;
+//# sourceMappingURL=yahHandler.d.ts.map

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

@@ -0,0 +1 @@
+const t="yah";export function createYahHandler({renderer:a,iconProvider:n,floorContext:s,layer:e}){return c=>{if(!c){a.setIcon("yah",null),a.flush();return}const l=s.isLayerVisible(c.layer);a.setIcon("yah",{canvas:n.getIcon("yah").canvas,layer:e,x:c.x,y:c.y,hidden:!l,dimmed:!l,origin:[.5,1]}),a.flush()}}

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

@@ -0,0 +1,14 @@
+/**
+ * Layer name constants — the contract between scene setup (config-all.ts)
+ * and the wayfinding runtime that fills these layers via the renderer.
+ *
+ * TODO(future): when renderer learns to create layers dynamically inside
+ * createWayfindingRenderer, these constants disappear — runtime will pass
+ * IconConfigs without naming layers, and config-all.ts will not pre-create
+ * any wf-* layers.
+ */
+export declare const WF_POINTS_LAYER_NAME = "wf-points";
+export declare const WF_TRAIL_LAYER_NAME = "wf-trail-points";
+export declare const WF_LINES_LAYER_NAME = "wf-lines";
+export declare const WF_LINES_ANIMATED_LAYER_NAME = "wf-lines-animated";
+//# sourceMappingURL=layers.d.ts.map