@expofp/floorplan 3.0.0-alpha.16 → 3.0.0-alpha.17

package/dist/esm/wayfinding/_PLAN-public-api.d.ts

@@ -0,0 +1,220 @@
+export type Unsubscribe = () => void;
+export interface Point {
+    x: number;
+    y: number;
+    layer: string;
+}
+export interface RouteEstimation {
+    /** Длина маршрута в единицах пространства */
+    distance: number;
+    /** Примерное время в секундах */
+    duration: number;
+}
+export interface Route {
+    points: Point[];
+    estimation: RouteEstimation;
+}
+export interface RouteResult {
+    primary: Route;
+    alternatives: Route[];
+}
+export interface RouteRequest {
+    from: Point;
+    to: Point;
+}
+export interface MultiPointRouteRequest {
+    points: [Point, Point, ...Point[]];
+    /**
+     * false (дефолт) — маршрут строится в переданном порядке точек.
+     * true — порядок промежуточных точек оптимизируется (TSP).
+     * Старт и финиш (первая и последняя точки) всегда фиксированы.
+     */
+    optimize?: boolean;
+}
+export type ManeuverType = 'straight' | 'turn-left' | 'turn-right' | 'turn-slight-left' | 'turn-slight-right' | 'u-turn' | 'take-elevator' | 'take-stairs' | 'take-escalator' | 'exit-building' | 'enter-building' | 'change-layer' | 'arrive';
+export interface Instruction {
+    type: ManeuverType;
+    /** Локализованный текст */
+    text: string;
+    /** Расстояние до следующего манёвра */
+    distance: number;
+    bearing?: number;
+    isLayerTransition: boolean;
+}
+export interface NavigationProgress {
+    status: 'active' | 'paused' | 'arrived' | 'off-route';
+    currentInstruction: Instruction;
+    nextInstruction: Instruction | null;
+    distanceToNextManeuver: number;
+    distanceToDestination: number;
+    /** Секунды */
+    timeToDestination: number;
+    currentLayer: string;
+    /** Позиция пользователя привязанная к маршруту */
+    snappedPoint: Point;
+    offRouteDistance?: number;
+}
+export interface UserPosition {
+    point: Point;
+    heading?: number;
+}
+export interface MarkerIcon {
+    svg: string;
+    width?: number;
+    height?: number;
+}
+export interface RouteLineStyle {
+    color?: string;
+    width?: number;
+    opacity?: number;
+}
+export type RouteAnimation = (lines: LineDef[], route: Route) => () => void;
+export interface LineDef {
+    points: [Vector2Like, Vector2Like];
+    color: string;
+    width: number;
+}
+export interface Vector2Like {
+    x: number;
+    y: number;
+}
+export interface RendererStyle {
+    route?: RouteLineStyle;
+    animation?: RouteAnimation;
+    alternativeRoute?: {
+        line?: RouteLineStyle;
+        opacity?: number;
+    };
+    markers?: {
+        origin?: MarkerIcon;
+        destination?: MarkerIcon;
+        waypoint?: MarkerIcon;
+        userPosition?: MarkerIcon;
+        layerTransition?: {
+            up?: MarkerIcon;
+            down?: MarkerIcon;
+            /** Переход без смены уровня (например переход между корпусами на одном этаже) */
+            same?: MarkerIcon;
+        };
+    };
+}
+/**
+ * Рендерер — единственная визуальная зависимость wayfinding-модуля.
+ * Реализуй этот интерфейс если хочешь использовать свой рендерер.
+ */
+export interface WayfindingRenderer {
+    renderRoute(route: Route, style: RendererStyle): void;
+    renderAlternatives(routes: Route[], style: RendererStyle): void;
+    clearRoute(): void;
+    renderPosition(position: UserPosition): void;
+    clearPosition(): void;
+    /** Переключить отображаемый слой */
+    setActiveLayer(layerId: string): void;
+    destroy(): void;
+}
+export interface WayfindingEventMap {
+    'route:ready': {
+        result: RouteResult;
+    };
+    'route:error': {
+        error: WayfindingError;
+    };
+    'route:cleared': Record<string, never>;
+    'navigation:started': {
+        route: Route;
+    };
+    'navigation:progress': {
+        progress: NavigationProgress;
+    };
+    'navigation:instruction': {
+        instruction: Instruction;
+    };
+    'navigation:deviation': {
+        offRouteDistance: number;
+    };
+    'navigation:rerouting': Record<string, never>;
+    'navigation:rerouted': {
+        result: RouteResult;
+    };
+    'navigation:arrived': Record<string, never>;
+    'navigation:stopped': Record<string, never>;
+    'navigation:paused': Record<string, never>;
+    'navigation:resumed': Record<string, never>;
+    'location:update': {
+        position: UserPosition;
+    };
+    'location:lost': Record<string, never>;
+    'layer:change': {
+        from: string | null;
+        to: string;
+    };
+    'error': {
+        error: WayfindingError;
+    };
+}
+export type WayfindingEventName = keyof WayfindingEventMap;
+export type WayfindingErrorCode = 'NO_ROUTE_FOUND' | 'SPACE_NOT_LOADED' | 'LOCATION_UNAVAILABLE' | 'UNKNOWN';
+export interface WayfindingError {
+    code: WayfindingErrorCode;
+    message: string;
+    cause?: unknown;
+}
+export interface WayfindingEngineConfig {
+    /**
+     * Данные пространства — передаются как есть.
+     * Engine сам определяет формат (lines/lineEnds, GeoJSON, NavMesh, Grid…)
+     * через зарегистрированные адаптеры.
+     */
+    space: unknown;
+    /**
+     * Рендерер — рисует маршрут, маркеры, анимацию.
+     * Передай свой если уже есть своя карта.
+     */
+    renderer: WayfindingRenderer;
+    /** Начальный стиль. Незаданные поля — дефолты рендерера. */
+    style?: RendererStyle;
+    rerouting?: {
+        /** Включить автоматический перерасчёт маршрута. По умолчанию false. */
+        enabled: boolean;
+        /** Расстояние отклонения от маршрута в единицах пространства после которого запускается перерасчёт */
+        threshold: number;
+    };
+    locale?: string;
+}
+export interface WayfindingEngine {
+    destroy(): void;
+    /** Построить маршрут. Результат также придёт событием 'route:ready'. */
+    route(request: RouteRequest): Promise<RouteResult>;
+    /** Построить маршрут через несколько точек в заданном порядке. */
+    routeMultiPoint(request: MultiPointRouteRequest): Promise<RouteResult>;
+    getCurrentRoute(): RouteResult | null;
+    clearRoute(): void;
+    startNavigation(): Promise<void>;
+    pauseNavigation(): void;
+    resumeNavigation(): void;
+    stopNavigation(): void;
+    getProgress(): NavigationProgress | null;
+    /**
+     * Обновить позицию пользователя.
+     * Если position.point.layer === 'unknown' — engine определит слой автоматически
+     * через snap к ближайшему узлу пространства и выдаст 'location:update'
+     * с разрешённым layer.
+     */
+    updatePosition(position: UserPosition): void;
+    on<E extends WayfindingEventName>(event: E, handler: (payload: WayfindingEventMap[E]) => void): Unsubscribe;
+    once<E extends WayfindingEventName>(event: E, handler: (payload: WayfindingEventMap[E]) => void): Unsubscribe;
+    /** Текущее состояние — для синхронного чтения при первом рендере */
+    getState(): WayfindingState;
+}
+/** Factory function — создаёт и инициализирует engine. */
+export declare function createWayfindingEngine(config: WayfindingEngineConfig): Promise<WayfindingEngine>;
+export interface WayfindingState {
+    route: RouteResult | null;
+    progress: NavigationProgress | null;
+    /** Текущий активный слой карты */
+    activeLayer: string | null;
+    /** Последняя известная позиция пользователя с разрешённым layer */
+    userPosition: UserPosition | null;
+    spaceLoaded: boolean;
+}
+//# sourceMappingURL=_PLAN-public-api.d.ts.map

package/dist/esm/wayfinding/_PLAN-public-api.js

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

package/dist/esm/{utils/wayfinding.d.ts → wayfinding/__integration__/legacy/legacyWayfinding.d.ts}

@@ -1,13 +1,12 @@
-import { Booth } from "../store/BoothStore";
+import { Booth } from "../../../store/BoothStore";
 export declare class RouteLine {
     p0: RoutePoint;
     p1: RoutePoint;
     unaccessible: boolean;
     unidirection: boolean;
     virtual: boolean;
-    ended: boolean;
     weight: number;
-    constructor(p0: RoutePoint, p1: RoutePoint, unaccessible: boolean, unidirection: boolean, virtual: boolean, ended: boolean, weight: number);
+    constructor(p0: RoutePoint, p1: RoutePoint, unaccessible: boolean, unidirection: boolean, virtual: boolean, weight: number);
 }
 export declare class RoutePoint {
     layer: string;
@@ -20,7 +19,9 @@ type Sublines = {
     lineEnds: RoutePoint[];
 };
 export declare let sublines: () => Sublines;
+export declare function resetPathFinder(): void;
+export declare function setSublines(fn: () => Sublines): void;
 export declare function getGraphLines(fromBooth: Booth, toBooth: Booth, onlyAccessible?: boolean, waypoints?: Booth[]): RouteLine[];
 export declare function getRouteLength(routeLines: RouteLine[]): number;
 export {};
-//# sourceMappingURL=wayfinding.d.ts.map
+//# sourceMappingURL=legacyWayfinding.d.ts.map

package/dist/esm/wayfinding/__integration__/legacy/legacyWayfinding.js

@@ -0,0 +1 @@
+import{lineAngle as L,lineLength as w,Point as u,pointInsideRectangle as F,Rect as I}from"simple-geometry";import $ from"../../../core/Polygon";import M from"../../graph/utils/a-star/a-star";import S from"ngraph.graph";export class RouteLine{p0;p1;unaccessible;unidirection;virtual;weight;constructor(n,r,s,a,i,t){this.p0=n,this.p1=r,this.unaccessible=s,this.unidirection=a,this.virtual=i,this.weight=t}}export class RoutePoint{layer;x;y;constructor(n,r,s){this.layer=n,this.x=r,this.y=s}}const P=e=>`${e.layer}_${e.x}_${e.y}`,b=(e,n)=>e.layer===n.layer&&w(e,n)<=1,W=(e,n,r)=>b(e.p0,n)&&b(e.p1,r)&&e.p0.layer===n.layer&&e.p1.layer===r.layer||b(e.p0,r)&&b(e.p1,n)&&e.p0.layer===r.layer&&e.p1.layer===n.layer;function _(e){const n=e.split("_");return[n[0],parseFloat(n[1]),parseFloat(n[2])]}export let sublines=()=>window.__wfData;let g={finder:null,oriented:!0,onlyAccessible:!1};export function resetPathFinder(){g.finder=null}export function setSublines(e){sublines=e}const k=0;function T(e,n){const r=S(),s=performance.now();let{lines:a}=sublines();a.forEach(t=>{(!n||!t.unaccessible)&&(r.addLink(P(t.p0),P(t.p1),{distance:t.virtual?k:w(t.p0,t.p1)/(t.weight||4)}),e&&!t.unidirection&&r.addLink(P(t.p1),P(t.p0),{distance:t.virtual?k:w(t.p1,t.p0)/(t.weight||4)}))}),g.oriented=e,g.onlyAccessible=n,g.finder=M(r,{oriented:e,distance(t,o,p){var d=1;if(o.parent){const h=_(o.parent?.node.id),f=_(o.node.id),m=_(t.id);var y=L({x:h[1],y:h[2]},{x:f[1],y:f[2]}),x=L({x:f[1],y:f[2]},{x:m[1],y:m[2]});y!==x&&(d=1.01)}return d*p.data.distance}});const i=performance.now();console.debug(`WF. Graph created. ~ ${i-s}ms.`)}function j(e,n,r){return e.filter(s=>W(s,n,r))[0]}export function getGraphLines(e,n,r=!1,s=[]){let a=performance.now();const i=$.fromRect(e.rect).rotate(e.rotate,e.rect.cx,e.rect.cy),t=$.fromRect(n.rect).rotate(n.rotate,n.rect.cx,n.rect.cy),o=new I(new u(i.x1,i.y1),new u(i.x2,i.y2),new u(i.x3,i.y3),new u(i.x4,i.y4)),p=new I(new u(t.x1,t.y1),new u(t.x2,t.y2),new u(t.x3,t.y3),new u(t.x4,t.y4)),d=new Map(s.map(l=>{const c=$.fromRect(l.rect).rotate(l.rotate,l.rect.cx,l.rect.cy);return[l.id,new I(new u(c.x1,c.y1),new u(c.x2,c.y2),new u(c.x3,c.y3),new u(c.x4,c.y4))]}));(!g.finder||g.onlyAccessible!==r)&&T(g.oriented,r);const y=[],x=[];let{lines:h,lineEnds:f}=sublines();for(let l=0;l<f.length;l++){const c=f[l],R=(c.layer===e.layer?.name||!e.layer)&&F(c,o),v=(c.layer===n.layer?.name||!n.layer)&&F(c,p);R&&y.push(c),v&&x.push(c)}const m=[],A=[y,...s.reduce((l,c)=>{const R=d.get(c.id);if(R){const v=f.filter(G=>(G.layer===c.layer?.name||!c.layer)&&F(G,R));v.length>0&&l.push(v)}return l},[]),x];if(m.push(...A.slice(1).map((l,c)=>D(A[c],l)).reverse().flat()),!m.length)return console.debug(`WF. Get graph lines: 0 ~ ${performance.now()-a}ms.`),[];const E=m.flatMap(l=>U(l.points,h));return console.debug(`WF. Get graph lines: ${E.length} ~ ${performance.now()-a}ms.`),E}function D(e,n){const r=[];for(let s=0;s<e.length;s++)for(let a=0;a<n.length;a++)try{const i=g.finder.find(P(e[s]),P(n[a]));if(!i.length)continue;let t=0,o=[];for(let p=0;p<i.length;p++){const d=i[p],y=i[p+1],x=d.id,h=_(x);o.push(new RoutePoint(h[0],h[1],h[2])),y&&(t+=d.links.find(f=>f.toId===x&&f.fromId===y.id).data.distance)}r.push({distance:t,points:o})}catch(i){console.warn(i)}return r.sort((s,a)=>s.distance-a.distance).slice(0,1)}function U(e,n){let r=[];for(let s=1;s<e.length;s++){const a=e[s-1],i=e[s];let t=j(n,a,i);if(!t)continue;let o=new RouteLine(a,i,t.unaccessible,t.unidirection,t.virtual,t.weight);w(t.p0,i)<w(t.p0,a)&&(o.p0=a,o.p1=i);const p=r[r.length-1],d=p?L(p.p0,p.p1):null,y=L(o.p0,o.p1);!p||p.virtual!==o.virtual||Math.abs(y-d)>5?r.push(o):p.p1=o.p1}return r}export function getRouteLength(e){return e.reduce((n,r)=>n+w(r.p0,r.p1),0)}

package/dist/esm/wayfinding/__tests__/helpers.d.ts

@@ -0,0 +1,21 @@
+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?: {
+    lines?: RouteLine[];
+    lineEnds?: RoutePoint[];
+}): GraphDataSource;
+export declare function createMockGraph(options?: {
+    lines?: RouteLine[];
+    lineEnds?: RoutePoint[];
+    hasNodeResult?: boolean | ((id: string) => boolean);
+    findResult?: PathNode[] | ((fromId: string, toId: string) => PathNode[]);
+    graphOptions?: GraphBuildOptions;
+}): GraphInstance;
+//# sourceMappingURL=helpers.d.ts.map

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

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

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

@@ -0,0 +1,12 @@
+import type { Booth } from "../../store/BoothStore";
+import type { RouteWaypoint } from "../types";
+/**
+ * Converts a MobX Booth entity to a framework-free RouteWaypoint.
+ *
+ * This adapter is exported as a public API for current consumers (RouteStore,
+ * config-wf.ts). In Phase 7, it will become an internal detail of
+ * MobxStateAdapter — the Booth→RouteWaypoint conversion will happen inside
+ * the state port, and callers will work with RouteWaypoint directly.
+ */
+export declare function boothToWaypoint(booth: Booth): RouteWaypoint;
+//# sourceMappingURL=boothToWaypoint.d.ts.map

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

@@ -0,0 +1 @@
+import{Point as t,Rect as c}from"simple-geometry";import n from"../../core/Polygon";export function boothToWaypoint(r){const e=n.fromRect(r.rect).rotate(r.rotate,r.rect.cx,r.rect.cy);return{x:r.rect.cx,y:r.rect.cy,layer:r.layer?.name,rect:new c(new t(e.x1,e.y1),new t(e.x2,e.y2),new t(e.x3,e.y3),new t(e.x4,e.y4))}}

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

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

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

@@ -0,0 +1 @@
+function n(){return window.__wfData}export const graphDataSource={getLines:()=>n()?.lines??[],getLineEnds:()=>n()?.lineEnds??[]};

package/dist/esm/wayfinding/graph/buildGraph.d.ts

@@ -0,0 +1,3 @@
+import { GraphBuildOptions, GraphDataSource, GraphInstance, PathFinder } from "../types";
+export declare function buildGraph(dataSource: GraphDataSource, pathFinder: PathFinder, options: GraphBuildOptions): GraphInstance;
+//# sourceMappingURL=buildGraph.d.ts.map

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

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

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

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

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

@@ -0,0 +1,3 @@
+/** Cost assigned to virtual (non-physical) route segments. Zero means virtual links are free (preferred by the pathfinder). */
+export declare const VIRTUAL_LINE_PENALTY = 0;
+//# sourceMappingURL=constants.d.ts.map

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

@@ -0,0 +1 @@
+export const VIRTUAL_LINE_PENALTY=0;

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

@@ -0,0 +1,14 @@
+import type { GraphInstance, ShortestPathResult, RoutePoint, RouteLine } from "../types";
+/** Computes the weighted path cost matching the graph link distance formula. */
+export declare function computeWeightedPathCost(points: RoutePoint[], lines: RouteLine[]): 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/graph/findShortestPath.js

@@ -0,0 +1 @@
+import{toNodeId as m,buildRouteSegments as p,findLineByEndpoints as P}from"./graphHelpers";import{linkCost as b}from"./linkCost";import{getRouteLength as x}from"../routing/getRouteLength";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=P(o,t[e-1],t[e]);i&&(n+=b(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:x(f)})}return i}

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1 @@
+import{lineLength as r}from"simple-geometry";import{VIRTUAL_LINE_PENALTY as o}from"./constants";const L=4;export function linkCost(t){return t.virtual?t.virtualLength??o:r(t.p0,t.p1)/(t.weight||L)}

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

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

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

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

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

@@ -0,0 +1,9 @@
+/**
+ * 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/graph/pathfinder/parseNodeId.js

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

@@ -0,0 +1,18 @@
+export type { RoutePoint, RouteLine, RouteResult, } from "./types";
+/**
+ * TODO: The exports below are temporary. They exist because RouteStore and config-wf.ts call wayfinding functions directly.
+ * When WayfindingRuntime and WayfindingStore are created (ARCHITECTURE.md phases 7-8), these will
+ * become internal implementation details and should be removed from the
+ * public barrel.
+ */
+export type { RouteWaypoint } from "./types";
+export { getGraphLines } from "./routing/getGraphLines";
+export { getRouteLength } from "./routing/getRouteLength";
+export { computeTransitionPoints } from "./rendering/computeTransitionPoints";
+export { normalizeRouteDirection } from "./rendering/normalizeRouteDirection";
+export { bezierCurve, splitPolyLine } from "./rendering/routeGeometry";
+export { createGraphCache } from "./graph/graphCache";
+export type { GraphCache } from "./graph/graphCache";
+export { boothToWaypoint } from "./adapters/boothToWaypoint";
+export { graphDataSource } from "./adapters/graphDataSource";
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/wayfinding/index.js

@@ -0,0 +1 @@
+export{getGraphLines}from"./routing/getGraphLines";export{getRouteLength}from"./routing/getRouteLength";export{computeTransitionPoints}from"./rendering/computeTransitionPoints";export{normalizeRouteDirection}from"./rendering/normalizeRouteDirection";export{bezierCurve,splitPolyLine}from"./rendering/routeGeometry";export{createGraphCache}from"./graph/graphCache";export{boothToWaypoint}from"./adapters/boothToWaypoint";export{graphDataSource}from"./adapters/graphDataSource";

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

@@ -0,0 +1,31 @@
+import type { RouteLine } from "../types";
+interface TransitionPointsInput {
+    /** Full route including virtual lines */
+    readonly routeLines: RouteLine[];
+    /** Current floor name (null = single-floor) */
+    readonly currentLayerName: string | null;
+    /** Floor names ordered low → high (from layerStore.floors) */
+    readonly floorOrder: string[];
+}
+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/rendering/computeTransitionPoints.js

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

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

@@ -0,0 +1,19 @@
+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) the lines must go from the origin to the destination.
+ *
+ * The function projects `from` and `to` onto `entireRouteLines` (the full
+ * multi-floor route) and reverses `routeLines` if `from` is closer to the
+ * polyline end than to its start.
+ *
+ * @param entireRouteLines  Full route across all floors (used to determine direction).
+ * @param routeLines        Lines to normalize (may be a floor-filtered subset).
+ * @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(entireRouteLines: RouteLine[], routeLines: RouteLine[], from: RoutePoint, to: RoutePoint): RouteLine[];
+//# sourceMappingURL=normalizeRouteDirection.d.ts.map

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

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

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

@@ -0,0 +1,16 @@
+import { Point, Line } from "simple-geometry";
+/**
+ * Recursive De Casteljau interpolation for a Bézier curve.
+ * Returns the point on the curve defined by `controlPoints` at parameter `t` (0–1).
+ */
+export declare function bezierCurve(controlPoints: Point[], t: number): Point;
+/**
+ * Splits a polyline (sequence of line segments) into evenly spaced points
+ * separated by `interval` units. Preserves the first and last points of the polyline.
+ *
+ * When segments meet at an angle, the remaining distance from the previous segment
+ * is projected onto the next segment direction (cosine correction) to maintain
+ * visually consistent spacing around corners.
+ */
+export declare function splitPolyLine(lines: Line[], interval: number): Point[];
+//# sourceMappingURL=routeGeometry.d.ts.map

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

@@ -0,0 +1 @@
+export function bezierCurve(t,e){if(t.length===0)return{x:0,y:0};if(t.length===1)return t[0];const s=[];for(let n=0;n<t.length-1;n++){const c=(1-e)*t[n].x+e*t[n+1].x,x=(1-e)*t[n].y+e*t[n+1].y;s.push({x:c,y:x})}return bezierCurve(s,e)}export function splitPolyLine(t,e){if(t.length===0)return[];if(e<=0)return[t[0].p0,t[t.length-1].p1];const s=[];let n=0;for(let o=0;o<t.length;o++){const M=t[o],p=M.p0,l=M.p1,u=l.x-p.x,a=l.y-p.y,h=Math.sqrt(u*u+a*a);if(h===0)continue;const w=u/h,X=a/h;let r=0;for(;n+r*e<=h;){const f=n+r*e,g=p.x+w*f,i=p.y+X*f;s.push({x:g,y:i}),r++}const Y=n+(r-1)*e;let y=h-Y;if(y=Math.max(y,0),o<t.length-1){const f=t[o+1],g=f.p0,i=f.p1,d=i.x-g.x,D=i.y-g.y,L=Math.sqrt(d*d+D*D);if(L===0)n=0;else{const q=d/L,b=D/L,z=w*q+X*b,A=y*z;n=e-A}}else n=e-y;n=Math.max(n,0)}const c=t[0].p0;(s.length===0||s[0].x!==c.x||s[0].y!==c.y)&&s.unshift(c);const x=t[t.length-1].p1,m=s[s.length-1];return(m.x!==x.x||m.y!==x.y)&&s.push(x),s}

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

@@ -0,0 +1,11 @@
+import type { GraphInstance, RoutePoint, 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/routing/buildMultiPointRoute.js

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

@@ -0,0 +1,9 @@
+import type { GraphInstance, RouteResult, RoutePoint } 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/routing/buildRoute.js

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

@@ -0,0 +1,21 @@
+import { Rect as SGRect } from "simple-geometry";
+import type { GraphDataSource, GraphInstance, RoutePoint } from "../types";
+/**
+ * Finds all graph endpoints (lineEnds) that fall inside the given containment rect.
+ * Uses simple-geometry's pointInsideRectangle for ~1% tolerance at boundaries,
+ * matching the legacy wayfinding behavior.
+ *
+ * The rect is a simple-geometry Rect (4-point polygon) — it may be rotated,
+ * not necessarily axis-aligned.
+ */
+export declare function findGraphPointsInRect(dataSource: GraphDataSource, containmentRect: SGRect, layer?: string): RoutePoint[];
+/**
+ * Finds the nearest graph endpoint by Euclidean distance from an arbitrary point.
+ * Generalizes the old rect-based filtering for point-to-point routing.
+ */
+export declare function findNearestGraphPoint(graph: GraphInstance, point: {
+    x: number;
+    y: number;
+    layer?: string;
+}): RoutePoint | null;
+//# sourceMappingURL=findNearestGraphPoint.d.ts.map

package/dist/esm/wayfinding/routing/findNearestGraphPoint.js

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

package/dist/esm/wayfinding/routing/getGraphLines.d.ts

@@ -0,0 +1,14 @@
+import type { RouteWaypoint, RouteLine, GraphDataSource } from "../types";
+/**
+ * High-level routing: resolves waypoints to route lines using a cached graph.
+ * Accepts `GraphDataSource` explicitly — no global configuration.
+ *
+ * Orchestrates two steps:
+ * 1. Resolve: waypoint → candidate graph points (via resolveWaypointCandidates)
+ * 2. Route: candidate points → shortest path via A* (via buildRoute / buildMultiPointRoute)
+ *
+ * Returns lines in **target→source** order — the convention used throughout
+ * the pipeline (see `aStarPathFinder.find()` JSDoc for rationale).
+ */
+export declare function getGraphLines(dataSource: GraphDataSource, from: RouteWaypoint, to: RouteWaypoint, onlyAccessible?: boolean, waypoints?: RouteWaypoint[]): RouteLine[];
+//# sourceMappingURL=getGraphLines.d.ts.map

package/dist/esm/wayfinding/routing/getGraphLines.js

@@ -0,0 +1 @@
+import{createGraphCache as f}from"../graph/graphCache";import{buildRoute as m}from"./buildRoute";import{buildMultiPointRoute as h}from"./buildMultiPointRoute";import{findGraphPointsInRect as p,findNearestGraphPoint as g}from"./findNearestGraphPoint";const C=f();function o(r,e){if(e.rect)return p(r.dataSource,e.rect,e.layer);const n=g(r,{x:e.x,y:e.y,layer:e.layer});return n?[n]:[]}export function getGraphLines(r,e,n,l=!1,a=[]){const u=performance.now(),t=C.getOrBuild(r,l),s=o(t,e),c=o(t,n),i=a.length>0?h(t,[s,...a.map(d=>o(t,d)),c]):m(t,s,c);return console.debug(`WF. Get graph lines: ${i.lines.length} ~ ${performance.now()-u}ms.`),i.lines}

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

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

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

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

package/dist/esm/wayfinding/routing/routeResult.d.ts

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