@expofp/floorplan 3.5.2 → 3.6.1

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

@@ -1 +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}}}}
+import{createGraphCache as G}from"./graph/graphCache";import{getRouteLength as m}from"./routing/getRouteLength";import{buildRoute as b}from"./routing/buildRoute";import{buildMultiPointRoute as R}from"./routing/buildMultiPointRoute";import{resolveWaypointCandidates as h}from"./routing/resolveWaypointCandidates";import{reorderWaypoints as y}from"./routing/optimizeWaypointOrder";const g=1e-6,u=(e,t)=>e.layer===t.layer&&Math.abs(e.x-t.x)<g&&Math.abs(e.y-t.y)<g;function O(e,t){if(!e.length)return e;const n=e[e.length-1],o=n.p1,r=u(t.segment.p0,o)?t.segment.p1:t.segment.p0;return u(n.p0,r)?[...e.slice(0,-1),{...n,p1:t.projection}]:[...e,{...t.segment,p0:o,p1:t.projection}]}function j(e,t){if(!e.length)return e;const n=e[0],o=n.p0,r=u(t.segment.p0,o)?t.segment.p1:t.segment.p0;return u(n.p1,r)?[{...n,p0:t.projection},...e.slice(1)]:[{...t.segment,p0:t.projection,p1:o},...e]}function E(e,t,n){let o=e;return t&&(o=O(o,t)),n&&(o=j(o,n)),o}export function createWayfindingEngine(e){const t=G();return{buildRoute(n,o,r){const i=t.getOrBuild(e,r?.accessible??!1),s=h(i,n),a=h(i,o),c=b(i,s.candidates,a.candidates),p=!!s.offGraphEntry||!!a.offGraphEntry,f=E(c.lines,s.offGraphEntry,a.offGraphEntry);return{lines:f,distance:p?m(f):c.totalDistance}},buildWaypointsRoute(n,o){if(n.length<2)return{lines:[],distance:0};const r=t.getOrBuild(e,o?.accessible??!1),s=(o?.fastest?y(n):n).map(d=>h(r,d)),a=R(r,s.map(d=>d.candidates)),c=s[0].offGraphEntry,p=s[s.length-1].offGraphEntry,f=!!c||!!p,l=E(a.lines,c,p);return{lines:l,distance:f?m(l):a.totalDistance}}}}

package/dist/esm/wayfinding/core/geometry/projectPointOnSegment.d.ts

@@ -0,0 +1,23 @@
+export interface SegmentProjection {
+    readonly projected: {
+        readonly x: number;
+        readonly y: number;
+    };
+    readonly distance: number;
+    readonly t: number;
+}
+interface Point2D {
+    readonly x: number;
+    readonly y: number;
+}
+/**
+ * Projects `point` onto the segment `a`–`b`, clamping the parameter `t` to
+ * `[0, 1]` so the result always lies on the segment (not its infinite line).
+ *
+ * `t` is the normalized position along the segment: `0` = `a`, `1` = `b`.
+ * For a zero-length segment (`a` equals `b`) the projection collapses to `a`
+ * with `t = 0`.
+ */
+export declare function projectPointOnSegment(point: Point2D, a: Point2D, b: Point2D): SegmentProjection;
+export {};
+//# sourceMappingURL=projectPointOnSegment.d.ts.map

package/dist/esm/wayfinding/core/geometry/projectPointOnSegment.js

@@ -0,0 +1 @@
+export function projectPointOnSegment(c,t,x){const e=x.x-t.x,n=x.y-t.y,y=e*e+n*n;if(y===0){const j=Math.hypot(c.x-t.x,c.y-t.y);return{projected:{x:t.x,y:t.y},distance:j,t:0}}const d=((c.x-t.x)*e+(c.y-t.y)*n)/y,o=Math.max(0,Math.min(1,d)),s=t.x+e*o,r=t.y+n*o,h=Math.hypot(c.x-s,c.y-r);return{projected:{x:s,y:r},distance:h,t:o}}

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

@@ -1,6 +1,8 @@
 export { createWayfindingEngine } from "./createWayfindingEngine";
 export type { WayfindingEngine, Route } from "./createWayfindingEngine";
-export type { GraphDataSource, RouteEndpoint, RouteLine, RoutePoint, RouteSnapResult, } from "./types";
+export type { GraphDataSource, RouteEndpoint, RouteLine, RoutePoint, RouteSnapResult, SnapToRouteConfig, } from "./types";
+export { projectPointOnSegment } from "./geometry/projectPointOnSegment";
+export type { SegmentProjection } from "./geometry/projectPointOnSegment";
 export { computeTransitionPoints } from "./rendering/computeTransitionPoints";
 export type { TransitionPointDef } from "./rendering/computeTransitionPoints";
 export { computeTrailPoints } from "./rendering/computeTrailPoints";
@@ -8,8 +10,9 @@ 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 { SNAP_THRESHOLD_METERS, getThresholdFromMetersToSvg, getThresholdSafe, resolveRerouteThresholdSvg, } from "./position/gpsThreshold";
+export { createRerouteController } from "./position/rerouteController";
+export type { RerouteController } from "./position/rerouteController";
 export { snapToRoute } from "./position/snapToRoute";
 export { splitRouteByPoint } from "./position/splitRouteByPoint";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-export{createWayfindingEngine}from"./createWayfindingEngine";export{computeTransitionPoints}from"./rendering/computeTransitionPoints";export{computeTrailPoints}from"./rendering/computeTrailPoints";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";
+export{createWayfindingEngine}from"./createWayfindingEngine";export{projectPointOnSegment}from"./geometry/projectPointOnSegment";export{computeTransitionPoints}from"./rendering/computeTransitionPoints";export{computeTrailPoints}from"./rendering/computeTrailPoints";export{computeBoundingBox}from"./rendering/routeGeometry";export{normalizeRouteDirection}from"./rendering/normalizeRouteDirection";export{getRouteLength}from"./routing/getRouteLength";export{SNAP_THRESHOLD_METERS,getThresholdFromMetersToSvg,getThresholdSafe,resolveRerouteThresholdSvg}from"./position/gpsThreshold";export{createRerouteController}from"./position/rerouteController";export{snapToRoute}from"./position/snapToRoute";export{splitRouteByPoint}from"./position/splitRouteByPoint";

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

@@ -18,5 +18,14 @@ export declare function getThresholdFromMetersToSvg({ thresholdInMeters, gpsConf
     thresholdInMeters?: number;
     gpsConfig?: GpsProjectionConfig;
 }): number;
+/**
+ * Resolves the reroute threshold (SVG units) for the active plan: honours
+ * `gpsConfig.rerouteThreshold` (meters) override, otherwise falls back to
+ * {@link REROUTE_THRESHOLD_METERS}. Returns plan-scaled SVG units suitable
+ * for `shouldReroute`.
+ */
+export declare function resolveRerouteThresholdSvg(gpsConfig?: GpsProjectionConfig & {
+    rerouteThreshold?: number;
+}): number;
 export {};
 //# sourceMappingURL=gpsThreshold.d.ts.map

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

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

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

@@ -0,0 +1,10 @@
+import type { RouteLine, RoutePoint } from "../types";
+/** Decides whether the current GPS tick warrants rebuilding the route. */
+export interface RerouteController {
+    /** Evaluates the current tick. Returns `true` when the caller should rebuild the route. */
+    shouldReroute(position: RoutePoint, routeLines: RouteLine[]): boolean;
+}
+/** `thresholdSvg` — plan-scale-aware off-route distance (SVG units), produced by
+ *  `resolveRerouteThresholdSvg` and passed in by the composition root. */
+export declare function createRerouteController(thresholdSvg: number): RerouteController;
+//# sourceMappingURL=rerouteController.d.ts.map

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

@@ -0,0 +1 @@
+import{distancePointToRouteOnLayer as o}from"./distanceToRoute";export function createRerouteController(n){return{shouldReroute(r,t){if(!t.length)return!1;const e=r.layer;return e&&!t.some(a=>a.p0.layer===e&&a.p1.layer===e)?!0:o({x:r.x,y:r.y,layer:e},t)>n}}}

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

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

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

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

package/dist/esm/wayfinding/core/routing/{findNearestGraphPoint.d.ts → graphPointResolvers.d.ts}

@@ -1,6 +1,4 @@
 import type { GraphDataSource, PolygonVertex, RoutePoint } from "../types";
 /** Graph endpoints inside a convex polygon (e.g. booth rect), filtered by layer. */
 export declare function findGraphPointsInPolygon(dataSource: GraphDataSource, polygon: ReadonlyArray<PolygonVertex>, layer?: string): RoutePoint[];
-/** Nearest graph endpoint by Euclidean distance, optionally filtered by layer. */
-export declare function findNearestGraphPoint(dataSource: GraphDataSource, point: RoutePoint): RoutePoint | null;
-//# sourceMappingURL=findNearestGraphPoint.d.ts.map
+//# sourceMappingURL=graphPointResolvers.d.ts.map

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

@@ -0,0 +1 @@
+import{computePolygonArea as i,pointInPolygon as p}from"../geometry/pointInPolygon";export function findGraphPointsInPolygon(r,o,n){const e=i(o);return r.getLineEnds().filter(t=>(!n||t.layer===n)&&p(t,o,e))}

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

@@ -1,4 +1,18 @@
-import type { GraphInstance, RouteEndpoint, RoutePoint } from "../types";
-/** Resolves a route endpoint to candidate graph points. */
-export declare function resolveWaypointCandidates(graph: GraphInstance, endpoint: RouteEndpoint): RoutePoint[];
+import type { GraphInstance, RouteEndpoint, RouteLine, RoutePoint } from "../types";
+export interface OffGraphEntry {
+    readonly segment: RouteLine;
+    readonly projection: RoutePoint;
+}
+/** A* candidates plus an optional `offGraphEntry` — set when the route's entry needs perpendicular
+ *  trim to land on a point inside a segment instead of at a graph node. */
+export interface ResolvedCandidates {
+    readonly candidates: RoutePoint[];
+    readonly offGraphEntry: OffGraphEntry | null;
+}
+/** Turns a route endpoint into A* candidates.
+ *  - Booth (has `bounds`) → graph nodes inside the polygon.
+ *  - Off-graph point → nearest segment on its layer; both ends are candidates and `offGraphEntry`
+ *    holds the perpendicular foot to trim to. If the foot falls off the segment, attach at its node.
+ * */
+export declare function resolveWaypointCandidates(graph: GraphInstance, endpoint: RouteEndpoint): ResolvedCandidates;
 //# sourceMappingURL=resolveWaypointCandidates.d.ts.map

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

@@ -1 +1 @@
-import{findGraphPointsInPolygon as a,findNearestGraphPoint as e}from"./findNearestGraphPoint";export function resolveWaypointCandidates(o,r){if(r.bounds?.length)return a(o.dataSource,r.bounds,r.layer);const t=e(o.dataSource,r);return t?[t]:[]}
+import{projectPointOnSegment as l}from"../geometry/projectPointOnSegment";import{findGraphPointsInPolygon as p}from"./graphPointResolvers";export function resolveWaypointCandidates(i,e){if(e.bounds?.length)return{candidates:p(i.dataSource,e.bounds,e.layer),offGraphEntry:null};let a=null,f=1/0;for(const t of i.dataSource.getLines()){if(t.virtual||e.layer&&t.p0.layer!==e.layer||t.p0.x===t.p1.x&&t.p0.y===t.p1.y)continue;const o=l(e,t.p0,t.p1);o.distance<f&&(f=o.distance,a={segment:t,proj:o})}if(!a)return{candidates:[],offGraphEntry:null};const{segment:n,proj:r}=a;return r.t===0?{candidates:[n.p0],offGraphEntry:null}:r.t===1?{candidates:[n.p1],offGraphEntry:null}:{candidates:[n.p0,n.p1],offGraphEntry:{segment:n,projection:{layer:n.p0.layer,x:r.projected.x,y:r.projected.y}}}}

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

@@ -64,12 +64,6 @@ export interface RouteResult {
     readonly lines: RouteLine[];
     readonly totalDistance: number;
 }
-/** 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;
 } | {
@@ -83,9 +77,14 @@ export type RouteSnapResult = {
  * Route endpoint: anchor on a layer, with optional perimeter polygon (booth bounds).
  * With `bounds` → engine picks the optimal graph node inside the polygon.
  * Without `bounds` → off-graph point (e.g. kiosk); engine snaps to nearest graph anchor.
+ *
+ * `id` is an opaque runtime discriminator the engine ignores — used by the
+ * adapter layer to mark off-graph endpoints (e.g. CP-derived vs kiosk anchor)
+ * so the renderer can branch on endpoint origin without re-checking UI types.
  */
 export interface RouteEndpoint extends RoutePoint {
     readonly bounds?: ReadonlyArray<PolygonVertex>;
+    readonly id?: string;
 }
 export type SnapToRouteConfig = {
     snapThreshold: number;

package/dist/esm/wayfinding/createWayfinding.js

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

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

@@ -11,4 +11,5 @@ 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";
+export declare const WF_CURRENT_POSITION_LAYER_NAME = "wf-current-position";
 //# sourceMappingURL=layers.d.ts.map

package/dist/esm/wayfinding/layers.js

@@ -1 +1 @@
-export const WF_POINTS_LAYER_NAME="wf-points",WF_TRAIL_LAYER_NAME="wf-trail-points",WF_LINES_LAYER_NAME="wf-lines",WF_LINES_ANIMATED_LAYER_NAME="wf-lines-animated";
+export const WF_POINTS_LAYER_NAME="wf-points",WF_TRAIL_LAYER_NAME="wf-trail-points",WF_LINES_LAYER_NAME="wf-lines",WF_LINES_ANIMATED_LAYER_NAME="wf-lines-animated",WF_CURRENT_POSITION_LAYER_NAME="wf-current-position";

package/dist/esm/wayfinding/runtime/createWayfindingRuntime.js

@@ -1 +1 @@
-import{getRouteLength as B,snapToRoute as G}from"../core";import{getRouteLines as H}from"./getRouteLines";import{createEndpointView as J}from"./endpointView";import{createPositionTrailView as K}from"./positionTrailView";import{createRouteLinesView as N}from"./routeLinesView";import{computeRouteRenderData as O}from"./routeRenderData";import{computeRouteUpdate as Q}from"./routeUpdate";import{createTrailView as X}from"./trailView";import{createTransitionView as Y}from"./transitionView";const Z=g=>g.flatMap(e=>[e.p0,e.p1]);export function createWayfindingRuntime({engine:g,renderer:e,iconProvider:h,floorContext:s,layers:a,snapThreshold:b,onTransitionClick:E,onRouteUpdate:d,onRouteDistance:m}){const L=J({renderer:e,iconProvider:h,floorContext:s,layer:a.points}),y=Y({renderer:e,iconProvider:h,floorContext:s,onTransitionClick:E,layer:a.points}),M=X({renderer:e,iconProvider:h,floorContext:s,layer:a.trail}),o=K({renderer:e,iconProvider:h,floorContext:s,trails:M,iconLayer:a.points,snapThreshold:b}),F=N({renderer:e,linesLayer:a.lines,animatedLinesLayer:a.linesAnimated});let u=[],i=null,r=null,l=null,c=0;function P(){return s.showAllFloors()?null:s.getActiveFloor()}function A(){const t=P();return t===null?u.filter(n=>!n.virtual):u.filter(n=>n.p0.layer===t&&!n.virtual)}function R(){if(!i||!r)return null;const t=A();return t.length?{from:i,to:r,routePoints:Z(t),visibleLines:t}:null}function f(t,n=!1){if(!i||!r)return;const p=O({routeLines:u,currentRouteLayer:P(),from:i,to:r,snap:t});F.draw(p,n),c=p.distance}function v(){if(!i||!r)return;const t=R();if(!t){L.hide(),y.clear(),o.refreshTrail(null),f();return}L.place(i,r,t.routePoints),y.place(u),f(),o.refreshTrail(t)}function T(){if(!l||!i||!r)return;const t=u.filter(p=>!p.virtual);if(!t.length)return;const n=R();return n?o.applyToRoute(l,n,t):(o.refreshTrail(null),G({x:l.x,y:l.y,z:l.layer||null},t,{snapThreshold:b,from:i,to:r}))}function I(){const t=Q(u,A());return d(t.lines,t.bounds),t}function S({from:t,to:n,waypoints:p,accessible:k}){const z=H({engine:g,from:t,to:n,waypoints:p,accessible:k});if(!z.length)return V(),!1;i=t,r=n,u=z,v();const{lines:q}=I(),w=T();return w&&f(w,!0),m(w?c:B(q)),e.flush(),!0}function U(t){if(l=t,!t){o.hideIcon(),o.refreshTrail(R()),f(),m(c),e.flush();return}o.placeIcon(t);const n=T();n&&f(n,!0),m(c),e.flush()}function W(){v();const t=T();t&&f(t,!0),u.length&&I(),m(c),e.flush()}function V(){u=[],i=null,r=null,c=0,L.hide(),y.clear(),o.clearTrail(),F.clear(),d([],null),m(0),e.flush()}function j(){V(),l=null,e.destroy()}return{setRoute:S,onPositionChanged:U,onFloorChanged:W,clearRoute:V,destroy:j}}
+import{CURRENT_POSITION_POINT_ID as C}from"./positionView";import{getRouteLength as G,snapToRoute as H}from"../core";import{getRouteLines as J}from"./getRouteLines";import{createEndpointView as K}from"./endpointView";import{createPositionTrailView as Q}from"./positionTrailView";import{createRouteLinesView as X}from"./routeLinesView";import{computeRouteRenderData as Y}from"./routeRenderData";import{computeRouteUpdate as Z}from"./routeUpdate";import{createTrailView as $}from"./trailView";import{createTransitionView as D}from"./transitionView";const x=A=>A.flatMap(e=>[e.p0,e.p1]);export function createWayfindingRuntime({engine:A,renderer:e,iconProvider:P,floorContext:c,layers:f,snapThreshold:E,onTransitionClick:M,onRouteUpdate:N,onRouteDistance:R}){const d=K({renderer:e,iconProvider:P,floorContext:c,layer:f.points}),I=D({renderer:e,iconProvider:P,floorContext:c,onTransitionClick:M,layer:f.points}),W=$({renderer:e,iconProvider:P,floorContext:c,layer:f.trail}),l=Q({renderer:e,iconProvider:P,floorContext:c,trails:W,iconLayer:f.currentPosition,snapThreshold:E}),O=X({renderer:e,linesLayer:f.lines,animatedLinesLayer:f.linesAnimated});let r=[],o=null,u=null,s=null,p=0,y=!1,T=!1;function S(){return c.showAllFloors()?null:c.getActiveFloor()}function _(){const t=S();return t===null?r.filter(n=>!n.virtual):r.filter(n=>n.p0.layer===t&&!n.virtual)}function V(){if(!o||!u)return null;const t=_();return t.length?{from:o,to:u,routePoints:x(t),visibleLines:t}:null}function m(t=null,n=!1){if(!o||!u)return;const i=Y({routeLines:r,currentRouteLayer:S(),from:o,to:u,snap:t});O.draw(i,n),p=i.distance}function g(t){const n=V();if(!n){l.setTrail(null,null);return}const i=s&&t&&!t.snapped?s:null,h=a=>a.bounds?.length?null:a.id===C?i:a,L=y?null:h(n.from);if(L){l.setTrail(n.routePoints[n.routePoints.length-1],L);return}const b=h(n.to);l.setTrail(b?n.routePoints[0]:null,b)}function U(){if(!o||!u)return;const t=V();if(!t){d.hide(),I.clear(),l.clearTrail(),m();return}d.place(o,u,t.routePoints,T),I.place(r),m(),g(null)}function w(){if(!o||!u)return;const t=V();t&&d.place(o,u,t.routePoints,T)}function F(){if(T=!1,!s||!o||!u)return null;const t=r.filter(h=>!h.virtual);if(!t.length)return null;const n=V(),i=n?l.applyToRoute(s,n,t):H(s,t,{snapThreshold:E,from:o,to:u});return i.snapped&&(y=!0),T=i.snapped,i}function k(){const t=Z(r,_());return N(t.lines,t.bounds),t}function j({from:t,to:n,waypoints:i,accessible:h}){const L=J({engine:A,from:t,to:n,waypoints:i,accessible:h});if(!L.length)return v(),!1;y=!1,o=t,u=n,r=L,U();const{lines:b}=k(),a=F();return w(),g(a),a&&m(a,!0),R(a?p:G(b)),e.flush(),!0}function q(t){const n=s!==null;if(s=t,!t){T=!1,l.hideIcon(),g(null),n&&w(),m(),R(p),e.flush();return}l.placeIcon(t);const i=F();w(),g(i),i&&m(i,!0),R(p),e.flush()}function z(){U();const t=F();w(),g(t),t&&m(t,!0),r.length&&k(),R(p),e.flush()}function v(){y=!1,r=[],o=null,u=null,p=0,d.hide(),I.clear(),l.clearTrail(),O.clear(),N([],null),R(0),e.flush()}function B(){v(),s=null,e.destroy()}return{setRoute:j,onPositionChanged:q,onFloorChanged:z,clearRoute:v,destroy:B}}

package/dist/esm/wayfinding/runtime/endpointView.d.ts

@@ -3,7 +3,10 @@ import type { RouteEndpoint, RoutePoint } from "../core";
 import type { WayfindingRenderer } from "../renderer";
 import type { FloorContext } from "./types";
 interface EndpointView {
-    place(from: RouteEndpoint, to: RouteEndpoint, visibleRoutePoints: ReadonlyArray<RoutePoint>): void;
+    /** Place source/destination icons. `snapped` — the live CP is currently on the route, so its
+     *  source shows greyed-out. A kiosk anchor (off-graph origin that isn't the CP) stays hidden;
+     *  everything else (booth, CP off-route, no live CP) shows full-colour. */
+    place(from: RouteEndpoint, to: RouteEndpoint, visibleRoutePoints: ReadonlyArray<RoutePoint>, snapped: boolean): void;
     hide(): void;
 }
 export declare function createEndpointView({ renderer, iconProvider, floorContext, layer, }: {

package/dist/esm/wayfinding/runtime/endpointView.js

@@ -1 +1 @@
-export function createEndpointView({renderer:n,iconProvider:c,floorContext:s,layer:t}){return{place(o,e,a){if(!a.length)return;const i=s.isLayerVisible(o.layer),d=s.isLayerVisible(e.layer),l=a[a.length-1],u=a[0];n.setIcon("source",{canvas:c.getIcon("source").canvas,layer:t,x:l.x,y:l.y,hidden:!i||!o.bounds,dimmed:!i,cardinalSnap:!0}),n.setIcon("destination",{canvas:c.getIcon("destination").canvas,layer:t,x:u.x,y:u.y,hidden:!d||!e.bounds,dimmed:!d,cardinalSnap:!0})},hide(){n.setIcon("source",null),n.setIcon("destination",null)}}}
+import{CURRENT_POSITION_POINT_ID as I}from"./positionView";function p(n,c){return!c||!n.bounds&&n.id!==I}export function createEndpointView({renderer:n,iconProvider:c,floorContext:e,layer:i}){return{place(s,o,t,l){if(!t.length)return;const a=e.isLayerVisible(s.layer),d=e.isLayerVisible(o.layer),u=t[t.length-1],r=t[0],y=s.id===I&&l;n.setIcon("source",{canvas:c.getIcon(y?"source_inactive":"source").canvas,layer:i,x:u.x,y:u.y,hidden:p(s,a),dimmed:!a,cardinalSnap:!0}),n.setIcon("destination",{canvas:c.getIcon("destination").canvas,layer:i,x:r.x,y:r.y,hidden:!d||!o.bounds,dimmed:!d,cardinalSnap:!0})},hide(){n.setIcon("source",null),n.setIcon("destination",null)}}}

package/dist/esm/wayfinding/runtime/positionTrailView.d.ts

@@ -4,9 +4,9 @@ import type { WayfindingRenderer } from "../renderer";
 import type { FloorContext, PositionInput } from "./types";
 import type { TrailView } from "./trailView";
 /**
- * Snapshot of the visible route the position-trail view operates on. The
- * runtime computes it (visibility filtering, route-points derivation) and
- * passes it in so the view stays free of route-state knowledge.
+ * Snapshot of the visible route the position-trail view operates on. The runtime computes it
+ * (visibility filtering, route-points derivation) and passes it in so the view stays free of
+ * route-state knowledge.
  */
 export interface RouteSnapshot {
     readonly from: RouteEndpoint;
@@ -15,10 +15,9 @@ export interface RouteSnapshot {
     readonly visibleLines: ReadonlyArray<RouteLine>;
 }
 /**
- * Owns the user-position icon and the single shared trail slot. The two
- * trail variants — off-graph endpoint trail (when an endpoint has no
- * `bounds`) and off-route position trail — are mutually exclusive and reuse
- * the same slot, so a single owner keeps the state machine simple.
+ * Owns the user-position icon and the single off-graph trail slot. The runtime decides which end of
+ * the route needs a trail (kiosk FROM, kiosk TO, or off-route CP FROM — never both at once in
+ * practice) and passes the corresponding `tip` + `anchor` here.
  */
 interface PositionTrailView {
     /** Place the position icon at the raw position. */
@@ -26,22 +25,17 @@ interface PositionTrailView {
     /** Hide the position icon. */
     hideIcon(): void;
     /**
-     * Snap the position to `routeLines` (caller-provided — typically the full
-     * non-virtual route across all floors) and update the trail slot.
-     * - Snapped: icon moves to the snap point; the off-graph endpoint trail
-     *   is restored (or cleared when neither endpoint is off-graph).
-     * - Off-route: a trail is drawn from the position to the nearest end of
-     *   the visible route; the icon stays where it was last placed.
+     * Snap the position to `routeLines` (caller-provided — typically the full non-virtual route
+     * across all floors) and place the position icon at the snap point or at the raw position.
+     * Returns the snap result; the trail is **not** touched — call `setTrail` separately.
      *
-     * `routeLines` is decoupled from `route.visibleLines` so the snap stays
-     * correct regardless of which floor is currently selected in the UI.
+     * `routeLines` is decoupled from `route.visibleLines` so the snap stays correct regardless of
+     * which floor is currently selected in the UI.
      */
     applyToRoute(position: PositionInput, route: RouteSnapshot, routeLines: ReadonlyArray<RouteLine>): RouteSnapResult;
-    /**
-     * Re-evaluate the trail when no position is active. Restores the
-     * off-graph endpoint trail when applicable; otherwise clears the slot.
-     */
-    refreshTrail(route: RouteSnapshot | null): void;
+    /** Draw the trail from `tip` (a route's graph endpoint) to `anchor` (the off-graph point).
+     *  Passing either as null hides the trail. */
+    setTrail(tip: RoutePoint | null, anchor: RoutePoint | null): void;
     /** Clear the trail slot (does not touch the icon). */
     clearTrail(): void;
 }

package/dist/esm/wayfinding/runtime/positionTrailView.js

@@ -1 +1 @@
-import{snapToRoute as P}from"../core";import{createPositionView as h}from"./positionView";const a="trail";export function createPositionTrailView({renderer:o,iconProvider:f,floorContext:y,trails:n,iconLayer:t,snapThreshold:p}){const c=h({renderer:o,iconProvider:f,layer:t});function i(e){if(!e.routePoints.length){n.clear(a);return}if(!e.from.bounds){n.place(a,e.routePoints[e.routePoints.length-1],{x:e.from.x,y:e.from.y,layer:e.from.layer});return}if(!e.to.bounds){n.place(a,e.routePoints[0],{x:e.to.x,y:e.to.y,layer:e.to.layer});return}n.clear(a)}return{placeIcon(e){const r=!y.isLayerVisible(e.layer);c.place(e,r)},hideIcon(){c.hide()},applyToRoute(e,r,s){const l=P({x:e.x,y:e.y,z:e.layer||null},[...s],{snapThreshold:p,from:r.from,to:r.to});if(l.snapped){i(r);const d=!y.isLayerVisible(e.layer);return c.place({...e,x:l.snappedPoint.x,y:l.snappedPoint.y},d),l}return r.routePoints.length?n.place(a,{x:e.x,y:e.y,layer:e.layer},r.routePoints[r.routePoints.length-1]):n.clear(a),l},refreshTrail(e){if(!e){n.clear(a);return}i(e)},clearTrail(){n.clear(a)}}}
+import{snapToRoute as T}from"../core";import{createPositionView as f}from"./positionView";const n="trail";export function createPositionTrailView({renderer:p,iconProvider:s,floorContext:l,trails:i,iconLayer:t,snapThreshold:d}){const r=f({renderer:p,iconProvider:s,layer:t});return{placeIcon(e){const a=!l.isLayerVisible(e.layer);r.place(e,a)},hideIcon(){r.hide()},applyToRoute(e,a,y){const c=T(e,[...y],{snapThreshold:d,from:a.from,to:a.to}),o=!l.isLayerVisible(e.layer);return c.snapped?r.place({...e,x:c.snappedPoint.x,y:c.snappedPoint.y},o):r.place(e,o),c},setTrail(e,a){e&&a?i.place(n,e,a):i.clear(n)},clearTrail(){i.clear(n)}}}

package/dist/esm/wayfinding/runtime/positionView.d.ts

@@ -1,6 +1,7 @@
 import type { IconProvider } from "../adapters";
 import type { WayfindingRenderer } from "../renderer";
 import type { PositionInput } from "./types";
+export declare const CURRENT_POSITION_POINT_ID = "current-position";
 interface PositionView {
     /**
      * Place or update the current-position icon. The icon variant (dot vs

package/dist/esm/wayfinding/runtime/positionView.js

@@ -1 +1 @@
-const c="position";export function createPositionView({renderer:o,iconProvider:a,layer:i}){return{place(n,e){const t=Number.isFinite(n.angle),s=t?"current_arrow":"current",r=t?n.angle*Math.PI/180:void 0;o.setIcon(c,{canvas:a.getIcon(s).canvas,layer:i,x:n.x,y:n.y,rotation:r,hidden:e,dimmed:e,origin:[.5,.5]})},hide(){o.setIcon(c,null)}}}
+export const CURRENT_POSITION_POINT_ID="current-position";const c="position";export function createPositionView({renderer:o,iconProvider:i,layer:s}){return{place(n,t){const e=Number.isFinite(n.angle),a=e?"current_arrow":"current",r=e?n.angle*Math.PI/180:void 0;o.setIcon(c,{canvas:i.getIcon(a).canvas,layer:s,x:n.x,y:n.y,rotation:r,hidden:t,dimmed:t,origin:[.5,.5]})},hide(){o.setIcon(c,null)}}}

package/dist/esm/wayfinding/runtime/routeRenderData.d.ts

@@ -23,7 +23,7 @@ export declare function computeRouteRenderData({ routeLines, currentRouteLayer,
     readonly currentRouteLayer: string | null;
     readonly from: RouteEndpoint;
     readonly to: RouteEndpoint;
-    readonly snap: RouteSnapResult | undefined;
+    readonly snap: RouteSnapResult | null;
 }): RouteRenderData;
 export {};
 //# sourceMappingURL=routeRenderData.d.ts.map

package/dist/esm/wayfinding/runtime/types.d.ts

@@ -14,6 +14,7 @@ export interface LayerNames {
     readonly trail: string;
     readonly lines: string;
     readonly linesAnimated: string;
+    readonly currentPosition: string;
 }
 export interface SetRouteInput {
     readonly from: RouteEndpoint;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@expofp/floorplan",
-  "version": "3.5.2",
+  "version": "3.6.1",
   "repository": {
     "type": "git",
     "url": "https://github.com/expofp/efp-app.git",
@@ -73,8 +73,8 @@
     "tslib": "^2.3.0",
     "uuid": "^9.0.1",
     "zod": "4.3.5",
-    "@expofp/debug": "3.5.2",
-    "@expofp/resolve": "3.5.2"
+    "@expofp/resolve": "3.6.1",
+    "@expofp/debug": "3.6.1"
   },
   "devDependencies": {
     "@babel/plugin-proposal-decorators": "^7.29.7",
@@ -89,6 +89,7 @@
     "@vitejs/plugin-react": "^6.0.2",
     "@vitest/browser": "^4.1.7",
     "@vitest/browser-playwright": "^4.1.7",
+    "eslint-plugin-jsx-a11y": "^6.10.2",
     "playwright": "^1.60.0",
     "react": "^19.2.7",
     "react-dom": "^19.2.7",
@@ -102,6 +103,11 @@
   },
   "nx": {
     "targets": {
+      "lint": {
+        "options": {
+          "fix": false
+        }
+      },
       "minify-esm": {
         "dependsOn": [
           "build",

package/dist/esm/RouteCutIn.d.ts

@@ -1,23 +0,0 @@
-import { SpecialBooth } from "./store/BoothStore";
-import Rect from "./core/Rect";
-export declare class RouteCutIn extends SpecialBooth {
-    readonly id: number;
-    readonly name: string;
-    readonly destination: LayerPoint;
-    readonly slug: string;
-    readonly meta: {};
-    protected readonly store: import("./store/BoothStore").default;
-    readonly exhibitors: never[];
-    readonly paths: never[];
-    readonly routePoint: LayerPoint;
-    readonly rect: Rect;
-    readonly entity: {
-        readonly type: "route-cut-in";
-    };
-    constructor(id: number, name: string, destination: LayerPoint, slug: string, meta?: {});
-    private findClosestRoutePoint;
-    private distanceToLine;
-    private findClosestPointOnLine;
-    private findClosestLineEnd;
-}
-//# sourceMappingURL=RouteCutIn.d.ts.map

package/dist/esm/RouteCutIn.js

@@ -1 +0,0 @@
-import{SpecialBooth as b}from"./store/BoothStore";import{graphDataSource as E}from"./wayfinding/adapters";import P from"./store";import D from"./core/Rect";import{areLayersEnabled as S}from"./utils/areLayersEnabled";export class RouteCutIn extends b{id;name;destination;slug;meta;store=P.boothStore;exhibitors=[];paths=[];routePoint;rect=D.fromCxcywh(0,0,0,0);entity={type:"route-cut-in"};constructor(i,r,n,s,t={}){super(),this.id=i,this.name=r,this.destination=n,this.slug=s,this.meta=t,this.layer=P.layerStore.findLayer(n.layer),this.routePoint=this.findClosestRoutePoint();const e=this.findClosestLineEnd(this.routePoint);e&&(this.rect=D.fromCxcywh(e.x,e.y,1,1)),Object.freeze(this)}findClosestRoutePoint(){const i=E.getLines(),r=S()?i.filter(t=>t.p0.layer===this.destination.layer&&t.p1.layer===this.destination.layer):i;if(!r?.length)return null;let n=1/0,s=null;return r.forEach(t=>{const e=this.distanceToLine(this.destination,t.p0,t.p1);e<n&&(n=e,s=t)}),{...this.findClosestPointOnLine(this.destination,s),layer:this.destination.layer}}distanceToLine(i,r,n){const s=i.x,t=i.y,e=r.x,o=r.y,l=n.x,d=n.y,x=s-e,h=t-o,a=l-e,u=d-o,m=x*a+h*u,f=a*a+u*u;let c=-1;f!==0&&(c=m/f);let y,p;c<0?(y=e,p=o):c>1?(y=l,p=d):(y=e+c*a,p=o+c*u);const L=s-y,C=t-p;return Math.sqrt(L*L+C*C)}findClosestPointOnLine(i,r){const{x:n,y:s}=r.p0,{x:t,y:e}=r.p1,{x:o,y:l}=i,d=o-n,x=l-s,h=t-n,a=e-s,u=d*h+x*a,m=h*h+a*a;let f=-1;m!==0&&(f=u/m);let c,y;return f<0?(c=n,y=s):f>1?(c=t,y=e):(c=n+f*h,y=s+f*a),{x:c,y}}findClosestLineEnd(i){if(!i)return null;const r=E.getLineEnds(),n=S()?r.filter(o=>o.layer===i.layer):r;let s=null,t=1/0;function e(o,l,d,x){return Math.sqrt((d-o)**2+(x-l)**2)}return n.forEach(o=>{const l=e(i.x,i.y,o.x,o.y);l<t&&(t=l,s=o)}),s}}

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

@@ -1,3 +0,0 @@
-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

@@ -1 +0,0 @@
-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/routing/findNearestGraphPoint.js

@@ -1 +0,0 @@
-import{lineLength as f}from"simple-geometry";import{computePolygonArea as l,pointInPolygon as a}from"../geometry/pointInPolygon";export function findGraphPointsInPolygon(r,n,t){const o=l(n);return r.getLineEnds().filter(e=>(!t||e.layer===t)&&a(e,n,o))}export function findNearestGraphPoint(r,n){let t=null,o=1/0;for(const e of r.getLineEnds()){if(n.layer&&e.layer!==n.layer)continue;const i=f(e,n);i<o&&(o=i,t=e)}return t}

package/dist/esm/wayfinding/utils/findBoothInRadius.d.ts

@@ -1,4 +0,0 @@
-import type { Booth } from "../../store/BoothStore";
-import type { CurrentPosition } from "../../store/RouteStore";
-export declare function findBoothInRadius(position: CurrentPosition | null, booths: Booth[], excludeBooths?: Booth[], radius?: number): Booth | null;
-//# sourceMappingURL=findBoothInRadius.d.ts.map

package/dist/esm/wayfinding/utils/findBoothInRadius.js

@@ -1 +0,0 @@
-const s=20;function f(n,i,t){const u=n<t.x1?t.x1-n:n>t.x2?n-t.x2:0,d=i<t.y1?t.y1-i:i>t.y2?i-t.y2:0;return u*u+d*d}export function findBoothInRadius(n,i,t=[],u=20){if(!n||!i.length)return null;const d=n.z!=null?String(n.z):null,o=u*u,r=new Set(t.filter(e=>e?.id).map(e=>String(e.id)));let a=null,c=1/0;for(const e of i){if(!e.rect||e.id&&r.has(String(e.id))||d&&e.layer?.name!==d)continue;const l=f(n.x,n.y,e.rect);l<=o&&l<c&&(c=l,a=e)}return a}