@expofp/floorplan 3.11.11 → 3.12.0

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

@@ -1,37 +0,0 @@
-import type { RenderableDef } from '@expofp/renderer';
-import type { LayerManager } from './layerManager';
-import type { IconConfig, RendererPort } from './types';
-/**
- * Manages `ImageDef` icons in the scene graph.
- *
- * Icons are keyed by `(name, key?)`. First `setIcon` creates the `ImageDef`;
- * subsequent calls mutate in place. Pass `config: null` to hide an icon
- * without destroying it.
- *
- * Exposes pure `applyScale`/`applyRoll`/`handleClick`/`handleHover` that the
- * app glue drives from engine events.
- */
-export interface IconManager {
-    /** Place, update, or hide an icon. See {@link WayfindingRenderer.setIcon}. */
-    setIcon(name: string, config: IconConfig | null, key?: string | number): void;
-    /** Hide all icons matching the given name(s). */
-    clearIcons(names: string | readonly string[]): void;
-    /** Hide every managed icon (used by `clearRoute`). */
-    hideAll(): void;
-    /** Clear internal state. */
-    destroy(): void;
-    /** Recompute bounds of all visible icons for `scale`; returns changed defs. */
-    applyScale(scale: number): RenderableDef[];
-    /** Apply camera roll to cardinal-snap icons; returns changed defs. */
-    applyRoll(cameraAngle: number): RenderableDef[];
-    /** Fire the first hit clickable icon's `onClick` from already-picked defs. */
-    handleClick(defs: readonly RenderableDef[]): void;
-    /** Whether a clickable icon is under the already-picked defs. */
-    handleHover(defs: readonly RenderableDef[]): boolean;
-}
-/**
- * Create an {@link IconManager} that places `ImageDef` icons into layers
- * managed by the given {@link LayerManager}.
- */
-export declare function createIconManager(layerManager: LayerManager, rendererPort: RendererPort): IconManager;
-//# sourceMappingURL=iconManager.d.ts.map

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

@@ -1 +0,0 @@
-import{Rect as f}from"@expofp/geometry";export function createIconManager(s,c){const l=new Map,r=new Map,u=new Map;function h(n,t){return t===void 0?n:`${n}#${t}`}function y(n,t){let e=r.get(n);e||(e=new Set,r.set(n,e)),e.add(t),u.set(t,n)}function D(n){const t=u.get(n);if(!t)return;const e=r.get(t);e&&e.delete(n),u.delete(n)}function m(n,t,e){const a=s.touchLayer(e.layer),o=c.getScale(),i=c.createImageDef(e.canvas,new f({x:e.x,y:e.y},{x:e.canvas.width*o,y:e.canvas.height*o},e.rotation),{hidden:e.hidden??!1,dim:e.dimmed??!1,origin:e.origin});a.children.push(i);const d={imageDef:i,layerName:e.layer,cardinalSnap:e.cardinalSnap??!1,callback:e.onClick??null};return l.set(n,d),y(t,n),d}function p(n,t,e,a){const o=s.resolveLayer(e.layerName),i=o.children,d=i.indexOf(e.imageDef);d>=0&&i.splice(d,1),s.touchedLayers.set(e.layerName,o),l.delete(n),D(n),m(n,t,a)}function v(n,t,e,a){if(e.layerName!==a.layer)throw new Error(`renderer: icon "${n}" cannot move between layers (was "${e.layerName}", got "${a.layer}")`);if(e.imageDef.source!==a.canvas){p(n,t,e,a);return}const o=c.getScale();e.imageDef.bounds=c.rectToRenderer(new f({x:a.x,y:a.y},{x:a.canvas.width*o,y:a.canvas.height*o},a.rotation)),e.imageDef.hidden=a.hidden??!1,e.imageDef.dim=a.dimmed??!1,e.callback=a.onClick??null,s.touchLayer(a.layer)}return{setIcon(n,t,e){const a=h(n,e);if(t===null){const i=l.get(a);i&&(i.imageDef.hidden=!0,i.callback=null,s.touchLayer(i.layerName));return}const o=l.get(a);o?v(a,n,o,t):m(a,n,t)},clearIcons(n){const t=typeof n=="string"?[n]:n;for(const e of t){const a=r.get(e);if(a)for(const o of a){const i=l.get(o);i&&(i.imageDef.hidden=!0,i.callback=null,s.touchLayer(i.layerName))}}},hideAll(){for(const n of l.values())n.imageDef.hidden=!0,n.callback=null,s.touchedLayers.set(n.layerName,s.resolveLayer(n.layerName))},destroy(){l.clear(),r.clear(),u.clear()},applyScale(n){const t=[];for(const e of l.values()){if(e.imageDef.hidden)continue;const{center:a,rotation:o}=e.imageDef.bounds;e.imageDef.bounds=c.rectToRenderer(new f({x:a.x,y:a.y},{x:e.imageDef.source.width*n,y:e.imageDef.source.height*n},o)),t.push(e.imageDef)}return t},applyRoll(n){const t=[];for(const e of l.values()){if(!e.cardinalSnap)continue;const a=c.getRotation(n,e.imageDef.bounds.rotation);a!==void 0&&(e.imageDef.bounds.rotation+=a,t.push(e.imageDef))}return t},handleClick(n){for(const t of l.values())if(t.callback&&!t.imageDef.hidden&&n.includes(t.imageDef)){t.callback();return}},handleHover(n){for(const t of l.values())if(t.callback&&!t.imageDef.hidden&&n.includes(t.imageDef))return!0;return!1}}}

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

@@ -1,3 +0,0 @@
-export { createWayfindingRenderer } from './createWayfindingRenderer';
-export type { IconConfig, RendererPort, WayfindingRenderer } from './types';
-//# sourceMappingURL=index.d.ts.map

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

@@ -1 +0,0 @@
-export{createWayfindingRenderer}from"./createWayfindingRenderer";

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

@@ -1,26 +0,0 @@
-import type { LayerDef } from '@expofp/renderer';
-import type { RendererPort } from './types';
-/**
- * Manages scene layer resolution, caching, dirty-tracking, and flush.
- *
- * Layers are resolved by name from `rendererPort.getLayers()` and cached. `touchLayer`
- * marks a layer as dirty; `flush` commits all dirty layers via `rendererPort.update`
- * in a single call.
- */
-export interface LayerManager {
-    /** Layers modified since the last {@link flush}. */
-    readonly touchedLayers: Map<string, LayerDef>;
-    /** Resolve a layer by name (cached). Throws if not found. */
-    resolveLayer(name: string): LayerDef;
-    /** Resolve a layer and mark it as dirty for the next {@link flush}. */
-    touchLayer(name: string): LayerDef;
-    /** Commit all dirty layers to `RendererService` and clear the dirty set. */
-    flush(): void;
-    /** Clear caches and dirty set. */
-    destroy(): void;
-}
-/**
- * Create a {@link LayerManager} bound to the given {@link RendererPort}.
- */
-export declare function createLayerManager(rendererPort: RendererPort): LayerManager;
-//# sourceMappingURL=layerManager.d.ts.map

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

@@ -1 +0,0 @@
-export function createLayerManager(s){const c=s.getLayers(),a=new Map,r=new Map;return{touchedLayers:r,resolveLayer(e){const t=a.get(e);if(t)return t;const n=c.find(o=>o.name===e);if(!n)throw new Error(`renderer: layer "${e}" not found in scene`);return a.set(e,n),n},touchLayer(e){const t=this.resolveLayer(e);return r.set(e,t),t},flush(){if(r.size!==0){for(const e of r.values())e.children=[...e.children];s.update(...r.values()),r.clear()}},destroy(){r.clear(),a.clear()}}}

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

@@ -1,7 +0,0 @@
-import type { LineDef } from '@expofp/renderer';
-export interface AnimationHandle {
-    stop: () => void;
-    getProgress: () => number;
-}
-export declare function animateLineSegments(lineSegments: LineDef[], callback: (segment: LineDef, segmentIndex: number, reset: boolean) => void, getScale: () => number, startProgress?: number): AnimationHandle | undefined;
-//# sourceMappingURL=lineAnimation.d.ts.map

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

@@ -1 +0,0 @@
-export function animateLineSegments(f,b,v,m=0){let i=0,r=0,c=null,s=null;if(!f.length)return;const a=f.map(t=>{const e=t.points[1].x-t.points[0].x,n=t.points[1].y-t.points[0].y;return Math.sqrt(e*e+n*n)}),l=a.reduce((t,e)=>t+e,0);if(!l)return;const F=Math.max(20,Math.min(l/2,300));function q(t){const e=t%1*l;let n=0;i=0,r=0;for(let o=0;o<a.length;o++){if(n+a[o]>e){i=o,r=e-n;break}n+=a[o],o===a.length-1&&(i=0,r=0)}}function M(t,e){const n=t.points[0],o=t.points[1],u=o.x-n.x,d=o.y-n.y,S=Math.sqrt(u*u+d*d),x=Math.min(e/S,1);return{points:[{x:n.x,y:n.y},{x:n.x+u*x,y:n.y+d*x}],color:t.color,width:t.width}}function h(t){c||(c=t);const e=(t-c)/1e3;c=t;const n=v();if(!(Number.isFinite(n)&&n>0)){s=requestAnimationFrame(h);return}const o=F*Math.sqrt(n);for(r+=o*e,r%=l;r>=a[i];)r-=a[i],i++,i>=f.length&&(i=0);const u=f[i],d=M(u,r);b(d,i,!1),s=requestAnimationFrame(h)}function p(){g(),m<=0&&(i=0,r=0),c=null,s=requestAnimationFrame(h)}function g(){s&&(cancelAnimationFrame(s),s=null,c=null)}function L(){if(l<=0)return 0;let t=0;for(let e=0;e<i;e++)t+=a[e];return t+=r,t/l}function y(){document.visibilityState==="visible"?p():g()}return m>0&&q(m),document.addEventListener("visibilitychange",y),p(),{stop:()=>{g(),document.removeEventListener("visibilitychange",y)},getProgress:L}}

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

@@ -1,41 +0,0 @@
-import type { LayerManager } from './layerManager';
-import type { RendererPort, RouteColors } from './types';
-/**
- * Manages static route lines (passed + remaining) and an animated overlay
- * on the remaining segment.
- */
-export interface RouteLineManager {
-    setRouteLines(passed: readonly {
-        readonly p0: {
-            x: number;
-            y: number;
-        };
-        readonly p1: {
-            x: number;
-            y: number;
-        };
-    }[], remaining: readonly {
-        readonly p0: {
-            x: number;
-            y: number;
-        };
-        readonly p1: {
-            x: number;
-            y: number;
-        };
-    }[], options: {
-        readonly linesLayer: string;
-        readonly animatedLinesLayer: string;
-        readonly resetAnimation?: boolean;
-    }): void;
-    /** Stop animation, wipe both lines layers. */
-    clearLines(): void;
-    /** Alias for {@link clearLines}. */
-    destroy(): void;
-}
-/**
- * Create a {@link RouteLineManager} that renders `LineDef` segments
- * into layers managed by the given {@link LayerManager}.
- */
-export declare function createRouteLineManager(layerManager: LayerManager, colors: RouteColors, rendererPort: RendererPort): RouteLineManager;
-//# sourceMappingURL=routeLineManager.d.ts.map

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

@@ -1 +0,0 @@
-import{animateLineSegments as D}from"./lineAnimation";export function createRouteLineManager(a,c,s){let e=null,n=null,i=null;return{setRouteLines(d,f,m){const L=a.touchLayer(m.linesLayer),l=a.touchLayer(m.animatedLinesLayer);n=L,i=l;const h=m.resetAnimation??!0;let u=0;e&&(h||(u=e.getProgress()),e.stop(),e=null);const p=d.map(t=>s.createLineDef(t,c.passed)),r=f.map(t=>s.createLineDef(t,c.remaining));if(L.children=[...p,...r],!r.length){l.children=[];return}const o=r.map(t=>({...t,color:c.active}));e=D(o,(t,y,g)=>{l.children=g?[]:[...o.slice(0,y),t],s.update(l)},()=>s.getScale(),u)??null},clearLines(){e&&(e.stop(),e=null),n&&(n.children=[],a.touchedLayers.set(n.name,n)),i&&(i.children=[],a.touchedLayers.set(i.name,i))},destroy(){this.clearLines()}}}

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

@@ -1,30 +0,0 @@
-import { type Point2Like } from '@expofp/geometry';
-import type { RenderableDef } from '@expofp/renderer';
-import type { LayerManager } from './layerManager';
-import type { RendererPort } from './types';
-/**
- * Manages named trails of evenly-spaced dots between two points.
- *
- * On camera zoom the app glue calls `applyScale` so dots are recalculated and
- * visual spacing stays constant.
- */
-export interface TrailManager {
-    /**
-     * Place, update, or remove a named trail.
-     * Pass `from/to = null` to remove the trail.
-     */
-    setTrail(name: string, from: Point2Like | null, to: Point2Like | null, options?: {
-        readonly canvas: HTMLCanvasElement;
-        readonly layer: string;
-    }): void;
-    /** Redraw all trails for `scale`; returns changed layer defs. */
-    applyScale(scale: number): RenderableDef[];
-    /** Remove all trails. */
-    destroy(): void;
-}
-/**
- * Create a {@link TrailManager} that renders dot trails into layers
- * managed by the given {@link LayerManager}.
- */
-export declare function createTrailManager(layerManager: LayerManager, rendererPort: RendererPort): TrailManager;
-//# sourceMappingURL=trailManager.d.ts.map

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

@@ -1 +0,0 @@
-import{Rect as w}from"@expofp/geometry";import{computeTrailPoints as d}from"../core";const m=40;export function createTrailManager(c,l){const o=new Map;function f(e){if(!e.dotDefs.length)return;const t=c.touchLayer(e.layerName),r=new Set(e.dotDefs);t.children=t.children.filter(a=>!r.has(a)),e.dotDefs=[]}function i(e,t){const r=c.touchLayer(e.layerName),a=m*t,n=d(e.from,e.to,a),s=e.canvas,y=n.map(h=>l.createImageDef(s,new w({x:h.x,y:h.y},{x:s.width*t,y:s.height*t})));f(e),r.children.push(...y),e.dotDefs=y}function u(e){const t=o.get(e);t&&(f(t),o.delete(e))}return{setTrail(e,t,r,a){if(t===null||r===null){u(e);return}if(!a)throw new Error(`renderer: setTrail("${e}") requires options when from/to are non-null`);const n=o.get(e);if(n){if(n.canvas!==a.canvas||n.layerName!==a.layer)throw new Error(`renderer: trail "${e}" cannot change canvas or layer after first call`);n.from=t,n.to=r,i(n,l.getScale());return}const s={from:t,to:r,canvas:a.canvas,layerName:a.layer,dotDefs:[]};o.set(e,s),i(s,l.getScale())},applyScale(e){const t=new Set;for(const r of o.values())i(r,e),t.add(c.touchLayer(r.layerName));return[...t]},destroy(){for(const e of[...o.keys()])u(e)}}}

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

@@ -1,129 +0,0 @@
-import type { Point2Like, Rect } from '@expofp/geometry';
-import type { ImageDef, ImageSource, LayerDef, LineDef, RenderableDef } from '@expofp/renderer';
-/**
- * The renderer this layer talks to, injected so it stays free of a concrete
- * renderer. Typed only against `@expofp/renderer` / `@expofp/geometry` so it
- * carries no dependency on `src/renderer`.
- */
-export interface RendererPort {
-    createImageDef(source: ImageSource, bounds: Rect, options?: {
-        hidden?: boolean;
-        dim?: boolean;
-        interactive?: boolean;
-        origin?: [number, number];
-    }): ImageDef;
-    createLineDef(line: {
-        p0: Point2Like;
-        p1: Point2Like;
-    }, color?: string, width?: number): LineDef;
-    getRotation(newAngle: number, currentRotation: number): number | undefined;
-    /** Convert a geometry rect to the renderer's bounds rect (`ImageDef['bounds']`). */
-    rectToRenderer(rect: Rect): ImageDef['bounds'];
-    /** Current camera point-scale. */
-    getScale(): number;
-    /** Scene root-layer children, used to resolve wf layers by name. */
-    getLayers(): LayerDef[];
-    /** Commit changed defs/layers to the renderer. */
-    update(...defs: RenderableDef[]): void;
-}
-export interface RouteColors {
-    readonly passed: string;
-    readonly remaining: string;
-    readonly active: string;
-}
-export interface IconConfig {
-    readonly canvas: HTMLCanvasElement;
-    /**
-     * Target layer name in the scene. Renderer locates the layer once per
-     * (name, layer) slot and reuses it.
-     *
-     * TODO(future): when renderer learns to create layers dynamically
-     * inside `createWayfindingRenderer`, this field is removed — renderer
-     * will own layer creation by icon name.
-     */
-    readonly layer: string;
-    readonly x: number;
-    readonly y: number;
-    /** Rotation in radians. */
-    readonly rotation?: number;
-    readonly hidden?: boolean;
-    readonly dimmed?: boolean;
-    /**
-     * Anchor point [0..1, 0..1]. Set at first setIcon for an icon key;
-     * ignored on subsequent updates (origin is fixed in ImageDef at creation).
-     */
-    readonly origin?: [number, number];
-    /**
-     * When true, renderer registers a camera-roll handler that snaps the icon
-     * rotation to the nearest cardinal direction (N/S/E/W, 90° steps) as the
-     * camera rotates past 45° thresholds. Used for label-like icons
-     * (source/destination/transition) that should remain readable.
-     *
-     * Do NOT enable for icons whose `rotation` carries meaning (e.g. position
-     * arrow heading, kiosk heading) — the snap would override that meaning.
-     *
-     * Set at first setIcon for an icon key; ignored on subsequent updates.
-     */
-    readonly cardinalSnap?: boolean;
-    readonly onClick?: () => void;
-}
-export interface WayfindingRendererConfig {
-    /** Optional color overrides; defaults applied if omitted. */
-    readonly colors?: Partial<RouteColors>;
-}
-/**
- * WayfindingRenderer — generic ImageDef/LineDef renderer for wayfinding visuals.
- *
- * Mutators (`setIcon`/`clearIcons`/`setTrail`/`setRouteLines`/`clearRoute`) only
- * mutate scene state; call `flush()` to commit a batch. The route animation tick
- * updates the renderer directly, outside any batch.
- */
-export interface WayfindingRenderer {
-    /**
-     * Place or update an icon by `(name, key)`. First call creates it in
-     * `config.layer`; later calls mutate in place. `config: null` hides it.
-     * `config.layer` must stay stable for a `(name, key)`. Buffered — `flush()` to commit.
-     */
-    setIcon(name: string, config: IconConfig | null, key?: string | number): void;
-    /** Hide every icon sharing one of `names` (kept alive for reuse). Buffered. */
-    clearIcons(names: string | readonly string[]): void;
-    /**
-     * Place or update a named dot trail between two points; `from/to = null`
-     * clears it. `options` required when non-null; `canvas`/`layer` must stay
-     * stable. Buffered — `flush()` to commit.
-     */
-    setTrail(name: string, from: Point2Like | null, to: Point2Like | null, options?: {
-        readonly canvas: HTMLCanvasElement;
-        readonly layer: string;
-    }): void;
-    /**
-     * Replace static route lines (passed + remaining) and (re)start the remaining
-     * animation. Buffered — `flush()` to commit.
-     */
-    setRouteLines(passed: readonly {
-        readonly p0: Point2Like;
-        readonly p1: Point2Like;
-    }[], remaining: readonly {
-        readonly p0: Point2Like;
-        readonly p1: Point2Like;
-    }[], options: {
-        readonly linesLayer: string;
-        readonly animatedLinesLayer: string;
-        readonly resetAnimation?: boolean;
-    }): void;
-    /** Recompute icon/trail bounds for `scale`; returns changed defs to render. */
-    applyScale(scale: number): RenderableDef[];
-    /** Apply camera roll to cardinal-snap icons; returns changed defs to render. */
-    applyRoll(cameraAngle: number): RenderableDef[];
-    /** Fire the hit clickable icon's `onClick` from already-picked defs. */
-    handleClick(defs: readonly RenderableDef[]): void;
-    /** Whether a clickable icon is under the already-picked defs (for cursor). */
-    handleHover(defs: readonly RenderableDef[]): boolean;
-    /** Clear route lines, drop trails, hide icons. Buffered — `flush()` to commit. */
-    clearRoute(): void;
-    /** Commit buffered mutations to the renderer (via the injected port). */
-    flush(): void;
-    /** Full teardown (managers cleared). Does NOT flush. */
-    destroy(): void;
-}
-//# sourceMappingURL=types.d.ts.map

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

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

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

@@ -1,3 +0,0 @@
-import type { WayfindingRuntime, WayfindingRuntimeConfig } from './types';
-export declare function createWayfindingRuntime({ engine, renderer, iconProvider, floorContext, layers, snapThreshold, onTransitionClick, onRouteUpdate, onRouteDistance, }: WayfindingRuntimeConfig): WayfindingRuntime;
-//# sourceMappingURL=createWayfindingRuntime.d.ts.map

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

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

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

@@ -1,18 +0,0 @@
-import { type RouteEndpoint, type RoutePoint } from '../core';
-import { type WayfindingRenderer } from '../renderer';
-import { type FloorContext, type IconProvider } from './types';
-interface EndpointView {
-    /** 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: readonly RoutePoint[], snapped: boolean): void;
-    hide(): void;
-}
-export declare function createEndpointView({ renderer, iconProvider, floorContext, layer, }: {
-    renderer: WayfindingRenderer;
-    iconProvider: IconProvider;
-    floorContext: FloorContext;
-    layer: string;
-}): EndpointView;
-export {};
-//# sourceMappingURL=endpointView.d.ts.map

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

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

@@ -1,13 +0,0 @@
-import { type RouteEndpoint, type RouteLine, type WayfindingEngine } from '../core';
-/**
- * Choose between `engine.buildRoute` and `engine.buildWaypointsRoute` based on
- * whether intermediate waypoints are supplied, and return the resulting route lines.
- */
-export declare function getRouteLines({ engine, from, to, waypoints, accessible, }: {
-    readonly engine: WayfindingEngine;
-    readonly from: RouteEndpoint;
-    readonly to: RouteEndpoint;
-    readonly waypoints?: readonly RouteEndpoint[];
-    readonly accessible: boolean;
-}): RouteLine[];
-//# sourceMappingURL=getRouteLines.d.ts.map

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

@@ -1 +0,0 @@
-export function getRouteLines({engine:t,from:u,to:e,waypoints:n,accessible:i}){return n?.length?t.buildWaypointsRoute([u,...n,e],{accessible:i}).lines:t.buildRoute(u,e,{accessible:i}).lines}

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

@@ -1,50 +0,0 @@
-import { type RouteEndpoint, type RouteLine, type RoutePoint, type RouteSnapResult } from '../core';
-import type { WayfindingRenderer } from '../renderer';
-import type { TrailView } from './trailView';
-import type { FloorContext, IconProvider, PositionInput } from './types';
-/**
- * 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;
-    readonly to: RouteEndpoint;
-    readonly routePoints: readonly RoutePoint[];
-    readonly visibleLines: readonly RouteLine[];
-}
-/**
- * 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. */
-    placeIcon(position: PositionInput): void;
-    /** Hide the position icon. */
-    hideIcon(): void;
-    /**
-     * 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.
-     */
-    applyToRoute(position: PositionInput, route: RouteSnapshot, routeLines: readonly RouteLine[]): RouteSnapResult;
-    /** 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;
-}
-export declare function createPositionTrailView({ renderer, iconProvider, floorContext, trails, iconLayer, snapThreshold, }: {
-    renderer: WayfindingRenderer;
-    iconProvider: IconProvider;
-    floorContext: FloorContext;
-    trails: TrailView;
-    iconLayer: string;
-    snapThreshold: number;
-}): PositionTrailView;
-export {};
-//# sourceMappingURL=positionTrailView.d.ts.map

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

@@ -1 +0,0 @@
-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,23 +0,0 @@
-import { type WayfindingRenderer } from '../renderer';
-import { type IconProvider, 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
-     * arrow) is derived from `input.angle`: finite angle → arrow, otherwise
-     * → dot.
-     *
-     * `hidden` collapses the monolith's dual (hidden, dimmed) fields into a
-     * single boolean — they were always driven by the same
-     * `!isLayerVisible(position.layer)` source.
-     */
-    place(input: PositionInput, hidden: boolean): void;
-    hide(): void;
-}
-export declare function createPositionView({ renderer, iconProvider, layer, }: {
-    renderer: WayfindingRenderer;
-    iconProvider: IconProvider;
-    layer: string;
-}): PositionView;
-export {};
-//# sourceMappingURL=positionView.d.ts.map

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

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

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

@@ -1,18 +0,0 @@
-import { type RouteLine } from '../core';
-import { type WayfindingRenderer } from '../renderer';
-interface RouteLinesView {
-    /** Push pre-split passed/remaining route lines to the renderer. */
-    draw(data: {
-        readonly passed: RouteLine[];
-        readonly remaining: RouteLine[];
-    }, preserveProgress?: boolean): void;
-    /** Clear all rendered route lines + animated segments. */
-    clear(): void;
-}
-export declare function createRouteLinesView({ renderer, linesLayer, animatedLinesLayer, }: {
-    renderer: WayfindingRenderer;
-    linesLayer: string;
-    animatedLinesLayer: string;
-}): RouteLinesView;
-export {};
-//# sourceMappingURL=routeLinesView.d.ts.map

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

@@ -1 +0,0 @@
-export function createRouteLinesView({renderer:t,linesLayer:e,animatedLinesLayer:o}){return{draw({passed:i,remaining:n},s=!1){t.setRouteLines(i,n,{linesLayer:e,animatedLinesLayer:o,resetAnimation:!s})},clear(){t.setRouteLines([],[],{linesLayer:e,animatedLinesLayer:o,resetAnimation:!0})}}}

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

@@ -1,29 +0,0 @@
-import { type RouteEndpoint, type RouteLine, type RouteSnapResult } from '../core';
-interface RouteRenderData {
-    /** Route lines behind the current user position (empty when no snap). */
-    readonly passed: RouteLine[];
-    /** Route lines ahead of the current user position (the full normalized route when no snap). */
-    readonly remaining: RouteLine[];
-    /** Remaining route distance along the polyline. */
-    readonly distance: number;
-}
-/**
- * Pure pipeline that produces the data needed to render the route: the
- * passed/remaining split for the visible floor plus the remaining
- * distance to the destination.
- *
- * The full non-virtual route is normalized to from→to direction once and
- * sliced down to the visible floor for rendering. The remaining distance
- * is read from `snap.distance` (computed once inside `snapToRoute`); when
- * no snap is active we fall back to the full route length.
- */
-export declare function computeRouteRenderData({ routeLines, currentRouteLayer, from, to, snap, }: {
-    readonly routeLines: RouteLine[];
-    /** null = show-all mode; otherwise the active route floor. */
-    readonly currentRouteLayer: string | null;
-    readonly from: RouteEndpoint;
-    readonly to: RouteEndpoint;
-    readonly snap: RouteSnapResult | null;
-}): RouteRenderData;
-export {};
-//# sourceMappingURL=routeRenderData.d.ts.map

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

@@ -1 +0,0 @@
-import{getRouteLength as u,normalizeRouteDirection as m,splitRouteByPoint as g}from"../core";export function computeRouteRenderData({routeLines:s,currentRouteLayer:r,from:a,to:c,snap:t}){const i=m(s.filter(n=>!n.virtual),a,c),o=n=>r===null?n:n.filter(p=>p.p0.layer===r);if(!t?.snapped)return{passed:[],remaining:o(i),distance:u(i)};const{passed:d,remaining:e}=g(i,t.snappedPoint),l=e!==i&&e.length>0?[{...e[0],p0:t.snappedPoint},...e.slice(1)]:e;return{passed:o(d),remaining:o(l),distance:t.distance}}

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

@@ -1,15 +0,0 @@
-import { type Box } from '@expofp/geometry';
-import { type RouteLine } from '../core';
-/**
- * Compute the payload for the runtime's `onRouteUpdate` callback:
- * - `lines`: route lines as the consumer sees them — virtual graph-internal
- *   segments are filtered out before publication.
- * - `bounds`: bounding box over the visible route points. It is an EMPTY box
- *   (`bounds.isEmpty()`) when the route is empty or collapses to a single point
- *   (no useful viewport to fit); consumers check `isEmpty()` rather than null.
- */
-export declare function computeRouteUpdate(routeLines: readonly RouteLine[], visibleLines: readonly RouteLine[]): {
-    lines: RouteLine[];
-    bounds: Box;
-};
-//# sourceMappingURL=routeUpdate.d.ts.map

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

@@ -1 +0,0 @@
-import{computeBoundingBox as r}from"../core";export function computeRouteUpdate(t,n){const p=t.filter(o=>!o.virtual),u=n.flatMap(o=>[o.p0,o.p1]),e=r(u);return{lines:p,bounds:e}}

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

@@ -1,20 +0,0 @@
-import { type RoutePoint } from '../core';
-import { type WayfindingRenderer } from '../renderer';
-import { type FloorContext, type IconProvider } from './types';
-/**
- * Callers choose the slot name and provide two route-points; the view draws a dotted trail between them (or hides
- * them if the layers are not on the active floor)
- */
-export interface TrailView {
-    /** Draws dotted points between two route-points in the named slot. */
-    place(slot: string, from: RoutePoint, to: RoutePoint): void;
-    clear(slot: string): void;
-    clearAll(): void;
-}
-export declare function createTrailView({ renderer, iconProvider, floorContext, layer, }: {
-    renderer: WayfindingRenderer;
-    iconProvider: IconProvider;
-    floorContext: FloorContext;
-    layer: string;
-}): TrailView;
-//# sourceMappingURL=trailView.d.ts.map

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

@@ -1 +0,0 @@
-export function createTrailView({renderer:r,iconProvider:c,floorContext:i,layer:u}){const a=new Set;function o(l,t){if(i.showAllFloors())return!0;const e=i.getActiveFloor();return e?l===e&&t===e:!1}function n(l){r.setTrail(l,null,null),a.delete(l)}return{place(l,t,e){if(!o(t.layer,e.layer)){n(l);return}r.setTrail(l,t,e,{canvas:c.getIcon("trail").canvas,layer:u}),a.add(l)},clear(l){n(l)},clearAll(){for(const l of a)r.setTrail(l,null,null);a.clear()}}}

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

@@ -1,17 +0,0 @@
-import { type RouteLine, type TransitionPointDef } from '../core';
-import type { WayfindingRenderer } from '../renderer';
-import type { FloorContext, IconProvider } from './types';
-interface TransitionView {
-    /** Recomputes transition points from route lines + floor context and places their icons. */
-    place(routeLines: RouteLine[]): void;
-    clear(): void;
-}
-export declare function createTransitionView({ renderer, iconProvider, floorContext, onTransitionClick, layer, }: {
-    renderer: WayfindingRenderer;
-    iconProvider: IconProvider;
-    floorContext: FloorContext;
-    onTransitionClick: (point: TransitionPointDef) => void;
-    layer: string;
-}): TransitionView;
-export {};
-//# sourceMappingURL=transitionView.d.ts.map

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

@@ -1 +0,0 @@
-import{computeTransitionPoints as f}from"../core";const a="transition";export function createTransitionView({renderer:t,iconProvider:r,floorContext:i,onTransitionClick:c,layer:s}){return{place(l){t.clearIcons(a);let e;if(i.showAllFloors())e=null;else{const o=i.getActiveFloor();if(!o)return;e=o}const u=f({routeLines:l,currentLayerName:e,floorOrder:i.getFloorOrder()});for(const[o,n]of u.entries())t.setIcon(a,{canvas:r.getIcon(p(n.role,n.direction)).canvas,layer:s,x:n.x,y:n.y,cardinalSnap:!0,onClick:n.role==="exit"?()=>c(n):void 0},o)},clear(){t.clearIcons(a)}}}function p(t,r){return t==="entry"?"transition_entry":r==="up"?"transition_up":r==="down"?"transition_down":"transition"}