@expofp/floorplan 3.11.11 → 3.12.0

package/dist/esm/wayfinding/core/graph/buildGraph.js

@@ -1 +0,0 @@
-export function buildGraph(l,i,e){return i.build(l.getLines(),{oriented:e.oriented??!0,onlyAccessible:e.onlyAccessible??!1}),{finder:i,dataSource:l,options:e}}

package/dist/esm/wayfinding/core/graph/buildNGraph.d.ts

@@ -1,9 +0,0 @@
-import { type Graph } from 'ngraph.graph';
-import { type GraphLine, type PathFinderOptions } from '../types';
-interface LinkData {
-    distance: number;
-}
-/** Builds an ngraph instance from route lines, filtering and linking per options. */
-export declare function buildNGraph(lines: GraphLine[], options: PathFinderOptions): Graph<unknown, LinkData>;
-export {};
-//# sourceMappingURL=buildNGraph.d.ts.map

package/dist/esm/wayfinding/core/graph/buildNGraph.js

@@ -1 +0,0 @@
-import p from"ngraph.graph";import{toNodeId as c}from"./graphHelpers";import{linkCost as a}from"./linkCost";export function buildNGraph(e,d){const{oriented:s,onlyAccessible:f}=d,n=p();for(const o of e){if(f&&o.unaccessible)continue;const t=c(o.p0),i=c(o.p1),r=a(o);n.addLink(t,i,{distance:r}),s&&!o.unidirection&&n.addLink(i,t,{distance:r})}return n}

package/dist/esm/wayfinding/core/graph/constants.d.ts

@@ -1,17 +0,0 @@
-/**
- * Default A* cost for a virtual (floor-transition) link. Non-zero so a floor
- * change costs more than any same-floor detour; otherwise floor changes are free
- * and a route between two points on one floor can detour through another.
- */
-export declare const VIRTUAL_LINE_PENALTY = 10000;
-/**
- * Fallback line weight when `line.weight` is 0 (meaning "not set" in floorplan data,
- * not "free passage").
- */
-export declare const DEFAULT_LINE_WEIGHT = 4;
-/**
- * Multiplier applied to a graph edge cost whenever the route changes direction at a node
- * (A* turn penalty).
- */
-export declare const TURN_PENALTY = 1.01;
-//# sourceMappingURL=constants.d.ts.map

package/dist/esm/wayfinding/core/graph/constants.js

@@ -1 +0,0 @@
-export const VIRTUAL_LINE_PENALTY=1e4,DEFAULT_LINE_WEIGHT=4,TURN_PENALTY=1.01;

package/dist/esm/wayfinding/core/graph/findShortestPath.d.ts

@@ -1,14 +0,0 @@
-import { type GraphInstance, type GraphLine, type RoutePoint, type ShortestPathResult } from '../types';
-/** Computes the weighted path cost matching the graph link distance formula. */
-export declare function computeWeightedPathCost(points: RoutePoint[], lines: GraphLine[]): number;
-/**
- * Finds the shortest path between candidate point sets by trying all from×to
- * pairs and picking the one with the lowest weighted cost.
- *
- * Complexity is O(N×M × A*) where N = |from|, M = |to|. In practice N, M ≤ 5
- * (rect-based booth candidates) or = 1 (nearest-point fallback), so the brute
- * force approach is acceptable. Multi-source A* would reduce this to a single
- * traversal but adds significant implementation complexity.
- */
-export declare function findShortestPath(graph: GraphInstance, from: RoutePoint[], to: RoutePoint[]): ShortestPathResult | null;
-//# sourceMappingURL=findShortestPath.d.ts.map

package/dist/esm/wayfinding/core/graph/findShortestPath.js

@@ -1 +0,0 @@
-import{getRouteLength as p}from"../routing/getRouteLength";import{buildRouteSegments as P,findLineByEndpoints as b,toNodeId as m}from"./graphHelpers";import{linkCost as x}from"./linkCost";function y(t,o,n){return{layer:t,x:o,y:n}}export function computeWeightedPathCost(t,o){let n=0;for(let e=1;e<t.length;e++){const i=b(o,t[e-1],t[e]);i&&(n+=x(i))}return n}export function findShortestPath(t,o,n){const e=t.dataSource.getLines();let i=null,d=1/0;for(const a of o)for(const g of n){const s=m(a),r=m(g);if(!t.finder.hasNode(s)||!t.finder.hasNode(r)){console.debug(`WF. findShortestPath: node not in graph, skipping pair ${s} \u2192 ${r}`);continue}const u=t.finder.find(s,r);if(!u.length)continue;const l=u.map(c=>y(c.layer,c.x,c.y)),f=P(l,e);if(!f.length)continue;const h=computeWeightedPathCost(l,e);h<d&&(d=h,i={lines:f,distance:p(f)})}return i}

package/dist/esm/wayfinding/core/graph/graphCache.d.ts

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

package/dist/esm/wayfinding/core/graph/graphCache.js

@@ -1 +0,0 @@
-import{buildGraph as i}from"./buildGraph";import{createAStarPathFinder as u}from"./pathfinder/aStarPathFinder";export function createGraphCache(){let r=null,t=!1;return{getOrBuild(a,e){if(r&&t===e)return r;const n=u();return r=i(a,n,{oriented:!0,onlyAccessible:e}),t=e,r}}}

package/dist/esm/wayfinding/core/graph/graphHelpers.d.ts

@@ -1,8 +0,0 @@
-import { type GraphLine, type RouteLine, type RoutePoint } from '../types';
-export declare const toNodeId: (p: RoutePoint) => string;
-export declare const arePointsClose: (p1: RoutePoint, p2: RoutePoint) => boolean;
-export declare const matchesLine: (line: GraphLine, p0: RoutePoint, p1: RoutePoint) => boolean;
-export declare function findLineByEndpoints(lines: GraphLine[], p0: RoutePoint, p1: RoutePoint): GraphLine | undefined;
-export declare function canMergeSegments(lastSegment: RouteLine, segment: RouteLine): boolean;
-export declare function buildRouteSegments(points: RoutePoint[], lines: GraphLine[]): RouteLine[];
-//# sourceMappingURL=graphHelpers.d.ts.map

package/dist/esm/wayfinding/core/graph/graphHelpers.js

@@ -1 +0,0 @@
-import{degToRad as a,lineAngle as u,pointDistance as f}from"@expofp/geometry";export const toNodeId=t=>`${t.layer}_${t.x}_${t.y}`;const p=1;export const arePointsClose=(t,n)=>t.layer===n.layer&&f(t,n)<=p,matchesLine=(t,n,e)=>arePointsClose(t.p0,n)&&arePointsClose(t.p1,e)||arePointsClose(t.p0,e)&&arePointsClose(t.p1,n);export function findLineByEndpoints(t,n,e){return t.find(o=>matchesLine(o,n,e))}const d=a(5);export function canMergeSegments(t,n){if(t.virtual!==n.virtual)return!1;const e=u(t.p0,t.p1),o=u(n.p0,n.p1);let r=Math.abs(o-e);return r>Math.PI&&(r=2*Math.PI-r),r<=d}export function buildRouteSegments(t,n){const e=[];for(let o=1;o<t.length;o++){const r=t[o-1],i=t[o],l=findLineByEndpoints(n,r,i);if(!l){console.warn(`WF: buildRouteSegments \u2014 no line found between ${toNodeId(r)} and ${toNodeId(i)}`);continue}const s={p0:r,p1:i,virtual:l.virtual},c=e[e.length-1];c&&canMergeSegments(c,s)?e[e.length-1]={...c,p1:s.p1}:e.push(s)}return e}

package/dist/esm/wayfinding/core/graph/linkCost.d.ts

@@ -1,4 +0,0 @@
-import { type GraphLine } from '../types';
-/** Weighted cost of a route line for A* graph edge (legacy formula). */
-export declare function linkCost(line: GraphLine): number;
-//# sourceMappingURL=linkCost.d.ts.map

package/dist/esm/wayfinding/core/graph/linkCost.js

@@ -1 +0,0 @@
-import{pointDistance as r}from"@expofp/geometry";import{DEFAULT_LINE_WEIGHT as o,VIRTUAL_LINE_PENALTY as i}from"./constants";export function linkCost(t){return t.virtual?t.virtualLength??i:r(t.p0,t.p1)/(t.weight||o)}

package/dist/esm/wayfinding/core/graph/pathfinder/aStarPathFinder.d.ts

@@ -1,3 +0,0 @@
-import { type PathFinder } from '../../types';
-export declare function createAStarPathFinder(): PathFinder;
-//# sourceMappingURL=aStarPathFinder.d.ts.map

package/dist/esm/wayfinding/core/graph/pathfinder/aStarPathFinder.js

@@ -1 +0,0 @@
-import{lineAngle as c}from"@expofp/geometry";import{buildNGraph as h}from"../buildNGraph";import{TURN_PENALTY as y}from"../constants";import g from"../utils/a-star/a-star";import{parseNodeId as f}from"./parseNodeId";function x(){return function(n,e,r){let t=1;if(e.parent){const[,a,l]=f(e.parent.node.id),[,o,d]=f(e.node.id),[,u,s]=f(n.id),p=c({x:a,y:l},{x:o,y:d}),m=c({x:o,y:d},{x:u,y:s});p!==m&&(t=y)}return t*r.data.distance}}export function createAStarPathFinder(){let i=null,n=null;return{build(e,r){n=h(e,r),i=g(n,{oriented:r.oriented,distance:x()})},hasNode(e){return n?!!n.hasNode(e):!1},find(e,r){if(!i)return[];const t=i.find(e,r);return t.length?t.map(a=>{const[l,o,d]=f(a.id);return{id:a.id,layer:l,x:o,y:d}}):[]}}}

package/dist/esm/wayfinding/core/graph/pathfinder/parseNodeId.d.ts

@@ -1,9 +0,0 @@
-/**
- * Decodes a node ID created by `pointId` back into [layer, x, y].
- *
- * Point IDs are formatted as "{layer}_{x}_{y}". Since layer names may
- * contain underscores (e.g. "floor_1"), we parse from the right where
- * x and y are always the last two segments.
- */
-export declare function parseNodeId(id: string): [string, number, number];
-//# sourceMappingURL=parseNodeId.d.ts.map

package/dist/esm/wayfinding/core/graph/pathfinder/parseNodeId.js

@@ -1 +0,0 @@
-export function parseNodeId(e){const t=e.lastIndexOf("_"),s=e.lastIndexOf("_",t-1);if(s===-1)throw new Error(`WF: invalid node ID format "${e}", expected "{layer}_{x}_{y}"`);return[e.substring(0,s),parseFloat(e.substring(s+1,t)),parseFloat(e.substring(t+1))]}

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

@@ -1,17 +0,0 @@
-export type { Route, WayfindingEngine } from './createWayfindingEngine';
-export { createWayfindingEngine } from './createWayfindingEngine';
-export type { GraphDataSource, GraphLine, RouteEndpoint, RouteLine, RoutePoint, RouteSnapResult, SnapToRouteConfig, } from './types';
-export type { SegmentProjection } from './geometry/projectPointOnSegment';
-export { projectPointOnSegment } from './geometry/projectPointOnSegment';
-export { computeTrailPoints } from './rendering/computeTrailPoints';
-export type { TransitionPointDef } from './rendering/computeTransitionPoints';
-export { computeTransitionPoints } from './rendering/computeTransitionPoints';
-export { normalizeRouteDirection } from './rendering/normalizeRouteDirection';
-export { computeBoundingBox } from './rendering/routeGeometry';
-export { getRouteLength } from './routing/getRouteLength';
-export { getThresholdFromMetersToSvg, getThresholdSafe, resolveRerouteThresholdSvg, SNAP_THRESHOLD_METERS, } from './position/gpsThreshold';
-export type { RerouteController } from './position/rerouteController';
-export { createRerouteController } 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 +0,0 @@
-export{createWayfindingEngine}from"./createWayfindingEngine";export{projectPointOnSegment}from"./geometry/projectPointOnSegment";export{computeTrailPoints}from"./rendering/computeTrailPoints";export{computeTransitionPoints}from"./rendering/computeTransitionPoints";export{normalizeRouteDirection}from"./rendering/normalizeRouteDirection";export{computeBoundingBox}from"./rendering/routeGeometry";export{getRouteLength}from"./routing/getRouteLength";export{getThresholdFromMetersToSvg,getThresholdSafe,resolveRerouteThresholdSvg,SNAP_THRESHOLD_METERS}from"./position/gpsThreshold";export{createRerouteController}from"./position/rerouteController";export{snapToRoute}from"./position/snapToRoute";export{splitRouteByPoint}from"./position/splitRouteByPoint";

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

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

@@ -1 +0,0 @@
-import{pointDistance as f}from"@expofp/geometry";function d(n,c,e,t,r,l){const i=r-e,s=l-t,a=n-e,u=c-t,y=i*i+s*s;if(y===0)return f({x:n,y:c},{x:e,y:t});let o=(a*i+u*s)/y;o<0?o=0:o>1&&(o=1);const x=e+o*i,b=t+o*s;return f({x:n,y:c},{x,y: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=d(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

@@ -1,31 +0,0 @@
-export declare const SNAP_THRESHOLD_METERS = 7.5;
-interface 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;
-/**
- * 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 +0,0 @@
-import{haversineDistance as i,pointDistance as c}from"@expofp/geometry";export const SNAP_THRESHOLD_METERS=7.5;const u=15,S=20;function h(t,r){const{p0:e,p2:o}=r,n=i(e,o),s=c(e,o);return!n||!s?0:t*(s/n)}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=h(t,r)),e||(e=S),e}export function resolveRerouteThresholdSvg(t){const r=getThresholdSafe(t?.rerouteThreshold)||u;return getThresholdFromMetersToSvg({thresholdInMeters:r,gpsConfig:t})}

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

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

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

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

@@ -1,4 +0,0 @@
-import { type RouteLine, type RoutePoint, type RouteSnapResult, type SnapToRouteConfig } from '../types';
-export { SNAP_THRESHOLD_METERS } from './gpsThreshold';
-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 +0,0 @@
-import{pointDistance as P}from"@expofp/geometry";import{pointInPolygon as E}from"../geometry/pointInPolygon";import{projectPointOnSegment as v}from"../geometry/projectPointOnSegment";function F(e,a){let p=0;for(const n of e){const o=P(n.p0,n.p1);if(o!==0){if(p+o>=a){const r=(a-p)/o,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}}p+=o}}const i=e[e.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(e,a,p){const i=a.length;if(!i)return{snapped:!1};const{snapThreshold:n,to:o,from:r,minRemainingUnits:h=.5}=p,s=e.layer||null;let D=1/0,m=null,u=0,b=s==null;for(let t=0;t<i;t++){const y=a[t],{p0:l,p1:f}=y,g=P(l,f);if(g===0)continue;if(s!=null&&String(l.layer)!==s){u+=g;continue}b=!0;const x=v({x:e.x,y:e.y},l,f);x.distance<D&&(D=x.distance,m={segmentIndex:t,t:x.t,distanceFromPolylineStart:u+g*x.t}),u+=g}if(s!=null&&!b)return{snapped:!1};const c=u,A=a[0].p0,I=a[i-1].p1,L=P(o,A),O=P(o,I),S=L<=O,T=Math.min(h,c);if(r?.bounds&&(s==null||!r.layer||r.layer===s)&&E({x:e.x,y:e.y},r.bounds)){const t=c,y=S?t:c-t,l=F(a,y);return{snapped:!0,snappedPoint:l.point,snappedLine:l.line,distance:t}}if(o.bounds&&(s==null||!o.layer||o.layer===s)&&E({x:e.x,y:e.y},o.bounds)){const t=T,y=c-t,f=F(a,S?t:y);return{snapped:!0,snappedPoint:f.point,snappedLine:f.line,distance:t}}if(!m||D>n)return{snapped:!1};let d=S?m.distanceFromPolylineStart:c-m.distanceFromPolylineStart;d<T&&(d=T);const j=c-d,R=F(a,S?d:j);return{snapped:!0,snappedPoint:R.point,snappedLine:R.line,distance:d}}

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

@@ -1,6 +0,0 @@
-import { type RouteLine, type RoutePoint } from '../types';
-export declare function splitRouteByPoint(routeLines: RouteLine[], snapPoint: RoutePoint): {
-    passed: RouteLine[];
-    remaining: RouteLine[];
-};
-//# sourceMappingURL=splitRouteByPoint.d.ts.map

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

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

@@ -1,19 +0,0 @@
-import { type Point2Like } from '@expofp/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): Point2Like[];
-//# sourceMappingURL=computeTrailPoints.d.ts.map

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

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

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

@@ -1,31 +0,0 @@
-import { type RouteLine } from '../types';
-interface TransitionPointsInput {
-    /** Full route including virtual lines */
-    readonly routeLines: RouteLine[];
-    /** 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[];
-}
-export interface TransitionPointDef {
-    readonly x: number;
-    readonly y: number;
-    /** Floor where the icon is rendered */
-    readonly layer: string;
-    /** Floor the transition leads to (for click-to-switch) */
-    readonly targetLayer: string;
-    readonly direction: 'up' | 'down' | 'neutral';
-    /** Whether this is an entry (arriving from another floor) or exit (leaving to another floor) in walking direction */
-    readonly role: 'entry' | 'exit';
-}
-/**
- * Computes deduplicated, correctly-directed transition points for the
- * current floor.
- *
- * Works directly with the full `routeLines` array (including virtual lines)
- * and does NOT depend on `routeNextFloor` — the target floor is read from
- * the opposite endpoint of each virtual line.
- */
-export declare function computeTransitionPoints(input: TransitionPointsInput): TransitionPointDef[];
-export {};
-//# sourceMappingURL=computeTransitionPoints.d.ts.map

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

@@ -1 +0,0 @@
-function s(a,n){return a.toLowerCase()===n.toLowerCase()}function d(a,n){return a.findIndex(r=>s(r,n))}function C(a,n,r){const o=d(a,n),t=d(a,r);return o===-1||t===-1?"neutral":t>o?"up":"down"}function w(a,n,r){return a.find(o=>s(o.p0.layer,n)?!r.has(o.p1.layer.toLowerCase()):s(o.p1.layer,n)?!r.has(o.p0.layer.toLowerCase()):!1)}function h(a,n,r,o){if(n.has(o.toLowerCase()))return o;let t=o;const l=new Set([r.toLowerCase(),t.toLowerCase()]);let u=w(a,t,l);for(;u&&(t=s(u.p0.layer,t)?u.p1.layer:u.p0.layer,!n.has(t.toLowerCase()));)l.add(t.toLowerCase()),u=w(a,t,l);return t}export function computeTransitionPoints(a){const{routeLines:n,currentLayerName:r,floorOrder:o}=a,t=n.filter(e=>e.virtual&&!s(e.p0.layer,e.p1.layer)),l=new Set;for(const e of n)e.virtual||(l.add(e.p0.layer.toLowerCase()),l.add(e.p1.layer.toLowerCase()));const c=(r?t.filter(e=>s(e.p0.layer,r)||s(e.p1.layer,r)):t).map(e=>{const i=r?s(e.p0.layer,r):!0,y=i?e.p0:e.p1,x=i?e.p1:e.p0,p=h(t,l,y.layer,x.layer);return{x:y.x,y:y.y,layer:y.layer,targetLayer:p,direction:C(o,y.layer,p),role:r&&i?"entry":"exit"}}),L=new Set(c.filter(e=>e.role==="exit").map(e=>`${e.x}:${e.y}`)),f=new Set;return c.filter(e=>{const i=`${e.x}:${e.y}`;return e.role==="entry"&&L.has(i)||f.has(i)?!1:(f.add(i),!0)})}

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

@@ -1,11 +0,0 @@
-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: readonly RouteLine[], currentFloor: string | null): RouteLine[];
-//# sourceMappingURL=getVisibleRouteLines.d.ts.map

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

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

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

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

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

@@ -1,11 +0,0 @@
-import { Box } from '@expofp/geometry';
-/**
- * Computes the axis-aligned bounding box of a set of points.
- * Always returns a {@link Box}. An empty array returns `Box.fromPoints([])` — a zero-size
- * box at the origin — which is distinguished from a real route bbox via `.isEmpty()`.
- */
-export declare function computeBoundingBox(points: readonly {
-    x: number;
-    y: number;
-}[]): Box;
-//# sourceMappingURL=routeGeometry.d.ts.map

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

@@ -1 +0,0 @@
-import{Box as n}from"@expofp/geometry";export function computeBoundingBox(o){return n.fromPoints(o)}

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

@@ -1,11 +0,0 @@
-import { type GraphInstance, type RoutePoint, type RouteResult } from '../types';
-/**
- * Builds a route through an ordered sequence of pre-resolved candidate groups.
- * Each group is a `RoutePoint[]` — the candidate graph points for one waypoint.
- *
- * Intermediate groups with no candidates (empty arrays) are silently skipped —
- * adjacent groups are connected directly. This matches the legacy behavior
- * where unreachable waypoints were omitted.
- */
-export declare function buildMultiPointRoute(graph: GraphInstance, candidateGroups: RoutePoint[][]): RouteResult;
-//# sourceMappingURL=buildMultiPointRoute.d.ts.map

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

@@ -1 +0,0 @@
-import{buildRoute as u}from"./buildRoute";import{emptyResult as o}from"./routeResult";export function buildMultiPointRoute(i,r){if(r.length<2)return o();const e=r.filter((t,l)=>l===0||l===r.length-1?!0:t.length>0);if(e.length<2)return o();if(e.length===2)return u(i,e[0],e[1]);const n=[];for(let t=0;t<e.length-1;t++)n.push(u(i,e[t],e[t+1]));n.reverse();const s=n.flatMap(t=>t.lines),f=n.reduce((t,l)=>t+l.totalDistance,0);return{lines:s,totalDistance:f}}

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

@@ -1,9 +0,0 @@
-import { type GraphInstance, type RoutePoint, type RouteResult } from '../types';
-/**
- * Builds a route between two sets of candidate graph points.
- *
- * This is pure pathfinding — it does not resolve waypoints to graph points.
- * Resolution is the caller's responsibility (see `getGraphLines`).
- */
-export declare function buildRoute(graph: GraphInstance, fromCandidates: RoutePoint[], toCandidates: RoutePoint[]): RouteResult;
-//# sourceMappingURL=buildRoute.d.ts.map

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

@@ -1 +0,0 @@
-import{findShortestPath as l}from"../graph/findShortestPath";import{emptyResult as n}from"./routeResult";export function buildRoute(i,e,r){if(!e.length||!r.length)return n();const t=l(i,e,r);return t?{lines:t.lines,totalDistance:t.distance}:n()}

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

@@ -1,3 +0,0 @@
-import { type RouteLine } from '../types';
-export declare function getRouteLength(routeLines: RouteLine[]): number;
-//# sourceMappingURL=getRouteLength.d.ts.map

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

@@ -1 +0,0 @@
-import{pointDistance as r}from"@expofp/geometry";export function getRouteLength(e){return e.reduce((o,t)=>o+r(t.p0,t.p1),0)}

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

@@ -1,4 +0,0 @@
-import { type GraphDataSource, type PolygonVertex, type RoutePoint } from '../types';
-/** Graph endpoints inside a convex polygon (e.g. booth rect), filtered by layer. */
-export declare function findGraphPointsInPolygon(dataSource: GraphDataSource, polygon: readonly PolygonVertex[], layer?: string): RoutePoint[];
-//# sourceMappingURL=graphPointResolvers.d.ts.map

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

@@ -1 +0,0 @@
-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/optimizeWaypointOrder.d.ts

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

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

@@ -1,18 +0,0 @@
-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 +0,0 @@
-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/routing/routeResult.d.ts

@@ -1,4 +0,0 @@
-import { type RouteResult } from '../types';
-/** Returns a fresh empty result each call to avoid shared-mutable-object bugs at runtime. */
-export declare const emptyResult: () => RouteResult;
-//# sourceMappingURL=routeResult.d.ts.map

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

@@ -1 +0,0 @@
-export const emptyResult=()=>({lines:[],totalDistance:0});

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

@@ -1,106 +0,0 @@
-export interface PolygonVertex {
-    readonly x: number;
-    readonly y: number;
-}
-export interface RoutePoint {
-    readonly x: number;
-    readonly y: number;
-    readonly layer: string;
-}
-/**
- * A computed route segment — the public output of routing, consumed by the
- * runtime and rendering. Carries only what consumers read; graph-build
- * properties (direction, cost) live on {@link GraphLine}, not here.
- */
-export interface RouteLine {
-    readonly p0: RoutePoint;
-    readonly p1: RoutePoint;
-    /** Virtual (floor-transition) link rather than a physical path segment. */
-    readonly virtual: boolean;
-}
-/**
- * A source graph line from external wayfinding data (wf.data.js) — the input to
- * graph building. Extends {@link RouteLine} with build-only properties
- * (accessibility, direction, cost) that never reach a computed route.
- */
-export interface GraphLine extends RouteLine {
-    /** Flagged inaccessible in source data: graph-build filter + the venue accessible toggle. */
-    readonly unaccessible: boolean;
-    /** One-way link: in oriented mode no reverse edge is added. */
-    readonly unidirection: boolean;
-    /** Link weight for cost (`0` = unset → `DEFAULT_LINE_WEIGHT`). */
-    readonly weight: number;
-    /**
-     * Optional custom cost for virtual (floor-transition) links, configured
-     * per-line in the designer as "Virtual length". When set, the pathfinder
-     * uses this value instead of the default VIRTUAL_LINE_PENALTY, overriding it
-     * per line — `0` makes the transition free (preferred), a large value makes
-     * it avoided. When unset, the non-zero default keeps routes on the same floor.
-     */
-    readonly virtualLength?: number;
-}
-export interface PathNode {
-    readonly id: string;
-    readonly layer: string;
-    readonly x: number;
-    readonly y: number;
-}
-export interface PathFinderOptions {
-    readonly oriented: boolean;
-    readonly onlyAccessible: boolean;
-}
-export interface PathFinder {
-    build(lines: GraphLine[], options: PathFinderOptions): void;
-    find(fromId: string, toId: string): PathNode[];
-    hasNode(id: string): boolean;
-}
-export interface GraphDataSource {
-    getLines(): GraphLine[];
-    getLineEnds(): RoutePoint[];
-}
-export interface GraphInstance {
-    readonly finder: PathFinder;
-    readonly dataSource: GraphDataSource;
-    readonly options: GraphBuildOptions;
-}
-export interface GraphBuildOptions {
-    readonly oriented?: boolean;
-    readonly onlyAccessible?: boolean;
-}
-export interface ShortestPathResult {
-    readonly lines: RouteLine[];
-    readonly distance: number;
-}
-export interface RouteResult {
-    readonly lines: RouteLine[];
-    readonly totalDistance: number;
-}
-export type RouteSnapResult = {
-    snapped: false;
-} | {
-    snapped: true;
-    snappedPoint: RoutePoint;
-    snappedLine: RouteLine;
-    /** Arc-length from `snappedPoint` to the destination, along the route. */
-    distance: number;
-};
-/**
- * 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?: readonly PolygonVertex[];
-    readonly id?: string;
-}
-export interface SnapToRouteConfig {
-    snapThreshold: number;
-    minRemainingUnits?: number;
-    to: RouteEndpoint;
-    from?: RouteEndpoint;
-}
-//# sourceMappingURL=types.d.ts.map

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

@@ -1 +0,0 @@
-export{};

package/dist/esm/wayfinding/renderer/createWayfindingRenderer.d.ts

@@ -1,13 +0,0 @@
-import type { RendererPort, WayfindingRenderer, WayfindingRendererConfig } from './types';
-/**
- * Create a {@link WayfindingRenderer} — the composition root that wires
- * together {@link LayerManager}, {@link IconManager}, {@link TrailManager},
- * and {@link RouteLineManager}.
- *
- * Exposes `applyScale`/`applyRoll`/`handleClick`/`handleHover` for the app glue
- * to drive from engine events.
- *
- * @throws If `rendererPort.getLayers()` throws (e.g. the scene is not started).
- */
-export declare function createWayfindingRenderer(rendererPort: RendererPort, config?: WayfindingRendererConfig): WayfindingRenderer;
-//# sourceMappingURL=createWayfindingRenderer.d.ts.map

package/dist/esm/wayfinding/renderer/createWayfindingRenderer.js

@@ -1 +0,0 @@
-import{createIconManager as i}from"./iconManager";import{createLayerManager as p}from"./layerManager";import{createRouteLineManager as y}from"./routeLineManager";import{createTrailManager as d}from"./trailManager";const g={passed:"#B5B7BC",remaining:"#A4CCE2",active:"#0794EA"};export function createWayfindingRenderer(r,c={}){const s={...g,...c.colors},o=p(r),e=i(o,r),n=d(o,r),t=y(o,s,r),l={setIcon:e.setIcon,clearIcons:e.clearIcons,setTrail:n.setTrail,setRouteLines:t.setRouteLines,applyScale:a=>[...e.applyScale(a),...n.applyScale(a)],applyRoll:a=>e.applyRoll(a),handleClick:a=>e.handleClick(a),handleHover:a=>e.handleHover(a),clearRoute(){t.clearLines(),n.destroy(),e.hideAll()},flush:o.flush,destroy(){l.clearRoute(),e.destroy(),n.destroy(),t.destroy(),o.destroy()}};return l}