@expofp/floorplan 3.2.5 → 3.2.7

package/dist/esm/wayfinding/layers.js

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

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

@@ -0,0 +1,14 @@
+import type { RendererService } from "../../renderer";
+import type { WayfindingRenderer, WayfindingRendererConfig } from "./types";
+/**
+ * Create a {@link WayfindingRenderer} — the composition root that wires
+ * together {@link LayerManager}, {@link IconManager}, {@link TrailManager},
+ * and {@link RouteLineManager}.
+ *
+ * Registers `pointer:click` and `pointer:move` listeners on the renderer
+ * canvas for icon interaction. Call `destroy()` to unregister them.
+ *
+ * @throws If `rendererService.scene` or `rendererService.renderer` is null.
+ */
+export declare function createWayfindingRenderer(rendererService: RendererService, config?: WayfindingRendererConfig): WayfindingRenderer;
+//# sourceMappingURL=createWayfindingRenderer.d.ts.map

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

@@ -0,0 +1 @@
+import{createLayerManager as d}from"./layerManager";import{createIconManager as m}from"./iconManager";import{createTrailManager as f}from"./trailManager";import{createRouteLineManager as u}from"./routeLineManager";const v={passed:"#B5B7BC",remaining:"#A4CCE2",active:"#0794EA"};export function createWayfindingRenderer(r,i={}){const l={...v,...i.colors},n=d(r),e=m(n,r),t=f(n,r),o=u(n,r,l),a=r.renderer;if(!a)throw new Error("renderer: rendererService.renderer is null \u2014 start RendererService before constructing renderer");a.events.addEventListener("pointer:click",e.handleClick),a.events.addEventListener("pointer:move",e.handleHover);const c={setIcon:e.setIcon,clearIcons:e.clearIcons,setTrail:t.setTrail,setRouteLines:o.setRouteLines,clearRoute(){o.clearLines(),t.destroy(),e.hideAll()},flush:n.flush,destroy(){c.clearRoute();const s=r.renderer;s&&(s.events.removeEventListener("pointer:click",e.handleClick),s.events.removeEventListener("pointer:move",e.handleHover)),e.destroy(),t.destroy(),o.destroy(),n.destroy()}};return c}

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

@@ -0,0 +1,31 @@
+import type { MouseEventData } from "@expofp/renderer";
+import type { RendererService } from "../../renderer";
+import type { IconConfig } from "./types";
+import type { LayerManager } from "./layerManager";
+/**
+ * Manages `ImageDef` icons in the scene graph.
+ *
+ * Icons are keyed by `(name, key?)`. First `setIcon` creates the `ImageDef`
+ * and registers scale/roll handlers; subsequent calls mutate in place.
+ * Pass `config: null` to hide an icon without destroying it.
+ */
+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 | ReadonlyArray<string>): void;
+    /** Hide every managed icon (used by `clearRoute`). */
+    hideAll(): void;
+    /** Unregister all scale/roll handlers and clear internal state. */
+    destroy(): void;
+    /** Pointer click handler — fires the first matching icon's `onClick`. */
+    handleClick(event: MouseEventData): void;
+    /** Pointer move handler — sets cursor to "pointer" when hovering a clickable icon. */
+    handleHover(event: MouseEventData): void;
+}
+/**
+ * Create an {@link IconManager} that places `ImageDef` icons into layers
+ * managed by the given {@link LayerManager}.
+ */
+export declare function createIconManager(layerManager: LayerManager, rendererService: RendererService): IconManager;
+//# sourceMappingURL=iconManager.d.ts.map

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

@@ -0,0 +1 @@
+import{createImageDef as w,getBounds as m,getRotation as L}from"../../renderer";import{pickDefaultScene as D}from"../../renderer/engine-core/defs";export function createIconManager(u,r){const l=new Map,d=new Map,f=new Map;function g(e,a){return a===void 0?e:`${e}#${a}`}function b(e,a){let t=d.get(e);t||(t=new Set,d.set(e,t)),t.add(a),f.set(a,e)}function k(e){const a=f.get(e);if(!a)return;const t=d.get(a);t&&t.delete(e),f.delete(e)}function h(e,a,t){const n=u.touchLayer(t.layer),i=w(t.canvas,m(t.x,t.y,t.canvas.width,t.canvas.height,r.scale,t.rotation),{hidden:t.hidden??!1,dim:t.dimmed??!1,origin:t.origin});n.children.push(i),r.onPtScale(e,c=>{const s=l.get(e);if(!(!s||s.imageDef.hidden))return s.imageDef.bounds=m(s.imageDef.bounds.center.x,s.imageDef.bounds.center.y,s.imageDef.source.width,s.imageDef.source.height,c,s.imageDef.bounds.rotation),s.imageDef}),t.cardinalSnap&&r.onRoll(e,c=>{const s=l.get(e);if(!s)return;const y=L(c,s.imageDef.bounds.rotation);if(y!==void 0)return s.imageDef.bounds.rotation+=y,s.imageDef});const o={imageDef:i,layerName:t.layer,callback:t.onClick??null};return l.set(e,o),b(a,e),o}function p(e,a,t,n){const i=u.resolveLayer(t.layerName),o=i.children,c=o.indexOf(t.imageDef);c>=0&&o.splice(c,1),u.touchedLayers.set(t.layerName,i),r.ptScaleRegistry.unregisterByName(e),r.rollRegistry.unregisterByName(e),l.delete(e),k(e),h(e,a,n)}function N(e,a,t,n){if(t.layerName!==n.layer)throw new Error(`renderer: icon "${e}" cannot move between layers (was "${t.layerName}", got "${n.layer}")`);if(t.imageDef.source!==n.canvas){p(e,a,t,n);return}t.imageDef.bounds=m(n.x,n.y,n.canvas.width,n.canvas.height,r.scale,n.rotation),t.imageDef.hidden=n.hidden??!1,t.imageDef.dim=n.dimmed??!1,t.callback=n.onClick??null,u.touchLayer(n.layer)}return{setIcon(e,a,t){const n=g(e,t);if(a===null){const o=l.get(n);o&&(o.imageDef.hidden=!0,o.callback=null,u.touchLayer(o.layerName));return}const i=l.get(n);i?N(n,e,i,a):h(n,e,a)},clearIcons(e){const a=typeof e=="string"?[e]:e;for(const t of a){const n=d.get(t);if(n)for(const i of n){const o=l.get(i);o&&(o.imageDef.hidden=!0,o.callback=null,u.touchLayer(o.layerName))}}},hideAll(){for(const e of l.values())e.imageDef.hidden=!0,e.callback=null,u.touchedLayers.set(e.layerName,u.resolveLayer(e.layerName))},destroy(){for(const e of l.keys())r.ptScaleRegistry.unregisterByName(e),r.rollRegistry.unregisterByName(e);l.clear(),d.clear(),f.clear()},handleClick({data:e}){const{defs:a}=D(e);for(const t of l.values())if(t.callback&&!t.imageDef.hidden&&a.includes(t.imageDef)){t.callback();return}},handleHover({data:e}){const a=r.renderer;if(!a)return;const{defs:t}=D(e);let n=!1;for(const i of l.values())if(i.callback&&!i.imageDef.hidden&&t.includes(i.imageDef)){n=!0;break}a.canvas.style.cursor=n?"pointer":""}}}

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

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

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

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

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

@@ -0,0 +1,27 @@
+import type { LayerDef } from "@expofp/renderer";
+import type { RendererService } from "../../renderer";
+/**
+ * Manages scene layer resolution, caching, dirty-tracking, and flush.
+ *
+ * Layers are resolved by name from `scene.rootLayer.children` and cached.
+ * `touchLayer` marks a layer as dirty; `flush` commits all dirty layers
+ * to `RendererService` in a single update 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 `RendererService`.
+ * Throws if `rendererService.scene` is null.
+ */
+export declare function createLayerManager(rendererService: RendererService): LayerManager;
+//# sourceMappingURL=layerManager.d.ts.map

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

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

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

@@ -0,0 +1,42 @@
+import type { RendererService } from "../../renderer";
+import type { RouteColors } from "./types";
+import type { LayerManager } from "./layerManager";
+/**
+ * Manages static route lines (passed + remaining) and an animated overlay
+ * on the remaining segment.
+ */
+export interface RouteLineManager {
+    setRouteLines(passed: ReadonlyArray<{
+        readonly p0: {
+            x: number;
+            y: number;
+        };
+        readonly p1: {
+            x: number;
+            y: number;
+        };
+    }>, remaining: ReadonlyArray<{
+        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, rendererService: RendererService, colors: RouteColors): RouteLineManager;
+//# sourceMappingURL=routeLineManager.d.ts.map

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

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

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

@@ -0,0 +1,27 @@
+import type { RendererService } from "../../renderer";
+import type { Point } from "./types";
+import type { LayerManager } from "./layerManager";
+/**
+ * Manages named trails of evenly-spaced dots between two points.
+ *
+ * Each trail has its own scale handler — when the camera zooms, dots are
+ * recalculated so visual spacing stays constant.
+ */
+export interface TrailManager {
+    /**
+     * Place, update, or remove a named trail.
+     * Pass `from/to = null` to remove the trail and unregister its scale handler.
+     */
+    setTrail(name: string, from: Point | null, to: Point | null, options?: {
+        readonly canvas: HTMLCanvasElement;
+        readonly layer: string;
+    }): void;
+    /** Remove all trails and unregister their scale handlers. */
+    destroy(): void;
+}
+/**
+ * Create a {@link TrailManager} that renders dot trails into layers
+ * managed by the given {@link LayerManager}.
+ */
+export declare function createTrailManager(layerManager: LayerManager, rendererService: RendererService): TrailManager;
+//# sourceMappingURL=trailManager.d.ts.map

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

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

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

@@ -0,0 +1,162 @@
+/**
+ * renderer public types.
+ *
+ * Generic, domain-neutral renderer abstraction over @expofp/renderer.
+ * Knows nothing about wayfinding domain (source/destination/transition/kiosk).
+ */
+export interface Point {
+    readonly x: number;
+    readonly y: number;
+}
+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.
+ *
+ * **Batching contract**: every mutator method (`setIcon`, `clearIcons`,
+ * `setTrail`, `setRouteLines`, `clearRoute`) only mutates
+ * internal state and scene-graph data structures. None of them push changes
+ * to `RendererService`. The caller MUST call `flush()` after a batch of
+ * mutations to commit them. This lets the caller group many changes into
+ * one render frame.
+ *
+ * Exceptions: animation tick + camera-scale handlers update the renderer
+ * directly because they fire asynchronously, outside any caller batch.
+ */
+export interface WayfindingRenderer {
+    /**
+     * Place or update an icon by `name`. `key` distinguishes multiple
+     * instances sharing the same name (transitions, kiosks).
+     *
+     * First call with a (name, key) pair creates an ImageDef in `config.layer`,
+     * registers a scale handler (and a roll handler if `cardinalSnap`), and
+     * stores the icon. Subsequent calls mutate the existing ImageDef in place
+     * (bounds, hidden, dim, onClick, source).
+     *
+     * Pass `config: null` to hide that icon (ImageDef stays alive for reuse).
+     *
+     * `config.layer` MUST stay stable for the same (name, key) — changing it
+     * after first call throws.
+     *
+     * **Buffered**: call `flush()` to commit.
+     */
+    setIcon(name: string, config: IconConfig | null, key?: string | number): void;
+    /**
+     * Hide every icon that shares one of the given `names`. ImageDefs stay
+     * alive for reuse on next `setIcon`.
+     *
+     * **Buffered**: call `flush()` to commit.
+     */
+    clearIcons(names: string | ReadonlyArray<string>): void;
+    /**
+     * Place or update a named trail of dots between two points. Multiple
+     * trails can coexist (e.g. one from-side, one to-side, possibly on
+     * different layers / floors). `name` identifies the trail; subsequent
+     * calls with the same `name` reuse its scale handler and replace its dots.
+     *
+     * Dot interval is fixed (visual constant). Renderer regenerates dots
+     * whenever the camera scale changes — count adapts so spacing stays
+     * constant.
+     *
+     * `options` is required when `from`/`to` are non-null. Pass both as `null`
+     * to clear that trail (no `options` needed).
+     *
+     * `options.canvas` and `options.layer` MUST stay stable for a given
+     * `name` — changing them after first call throws.
+     *
+     * **Buffered**: call `flush()` to commit.
+     */
+    setTrail(name: string, from: Point | null, to: Point | null, options?: {
+        readonly canvas: HTMLCanvasElement;
+        readonly layer: string;
+    }): void;
+    /**
+     * Replace the static route lines (passed + remaining) and (re)start the
+     * animation on the remaining segment.
+     *
+     * **Buffered**: call `flush()` to commit. The animation tick itself
+     * updates the renderer directly (it runs async outside caller batches).
+     */
+    setRouteLines(passed: ReadonlyArray<{
+        readonly p0: Point;
+        readonly p1: Point;
+    }>, remaining: ReadonlyArray<{
+        readonly p0: Point;
+        readonly p1: Point;
+    }>, options: {
+        /**
+         * TODO(future): remove. renderer will create this layer
+         * dynamically inside `createWayfindingRenderer` — caller will no
+         * longer pass layer names per call.
+         */
+        readonly linesLayer: string;
+        /**
+         * TODO(future): remove. Same as above — animated lines layer will
+         * be created in `createWayfindingRenderer`.
+         */
+        readonly animatedLinesLayer: string;
+        readonly resetAnimation?: boolean;
+    }): void;
+    /**
+     * Clear route lines, drop all trails, hide all icons. Icon ImageDefs stay
+     * alive for reuse; trail records and their scale handlers are removed.
+     *
+     * **Buffered**: call `flush()` to commit.
+     */
+    clearRoute(): void;
+    /**
+     * Commit all buffered mutations to `RendererService`. Pushes every layer
+     * touched since the last `flush()` (or since construction).
+     */
+    flush(): void;
+    /**
+     * Full teardown: `clearRoute()` + remove DOM listeners + unregister all
+     * scale and roll handlers. Does NOT call `flush()` — the renderer is
+     * going away, so committing pending changes is the caller's choice.
+     */
+    destroy(): void;
+}
+//# sourceMappingURL=types.d.ts.map

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

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

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

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

@@ -0,0 +1,16 @@
+import type { IconProvider } from "../adapters";
+import type { RouteEndpoint, RoutePoint } from "../core";
+import type { WayfindingRenderer } from "../renderer";
+import type { FloorContext } from "./types";
+interface EndpointView {
+    place(from: RouteEndpoint, to: RouteEndpoint, visibleRoutePoints: ReadonlyArray<RoutePoint>): void;
+    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

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

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

@@ -0,0 +1,13 @@
+import type { RouteEndpoint, RouteLine, 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?: ReadonlyArray<RouteEndpoint>;
+    readonly accessible: boolean;
+}): RouteLine[];
+//# sourceMappingURL=getRouteLines.d.ts.map

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

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

@@ -0,0 +1,57 @@
+import type { IconProvider } from "../adapters";
+import type { RouteEndpoint, RouteLine, RoutePoint, RouteSnapResult } from "../core";
+import type { WayfindingRenderer } from "../renderer";
+import type { FloorContext, PositionInput } from "./types";
+import type { TrailView } from "./trailView";
+/**
+ * Snapshot of the visible route the position-trail view operates on. The
+ * runtime computes it (visibility filtering, route-points derivation) and
+ * passes it in so the view stays free of route-state knowledge.
+ */
+export interface RouteSnapshot {
+    readonly from: RouteEndpoint;
+    readonly to: RouteEndpoint;
+    readonly routePoints: ReadonlyArray<RoutePoint>;
+    readonly visibleLines: ReadonlyArray<RouteLine>;
+}
+/**
+ * Owns the user-position icon and the single shared trail slot. The two
+ * trail variants — off-graph endpoint trail (when an endpoint has no
+ * `bounds`) and off-route position trail — are mutually exclusive and reuse
+ * the same slot, so a single owner keeps the state machine simple.
+ */
+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 update the trail slot.
+     * - Snapped: icon moves to the snap point; the off-graph endpoint trail
+     *   is restored (or cleared when neither endpoint is off-graph).
+     * - Off-route: a trail is drawn from the position to the nearest end of
+     *   the visible route; the icon stays where it was last placed.
+     *
+     * `routeLines` is decoupled from `route.visibleLines` so the snap stays
+     * correct regardless of which floor is currently selected in the UI.
+     */
+    applyToRoute(position: PositionInput, route: RouteSnapshot, routeLines: ReadonlyArray<RouteLine>): RouteSnapResult;
+    /**
+     * Re-evaluate the trail when no position is active. Restores the
+     * off-graph endpoint trail when applicable; otherwise clears the slot.
+     */
+    refreshTrail(route: RouteSnapshot | null): void;
+    /** 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

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

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

@@ -0,0 +1,23 @@
+import type { IconProvider } from "../adapters";
+import type { WayfindingRenderer } from "../renderer";
+import type { PositionInput } from "./types";
+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

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

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

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

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

@@ -0,0 +1,29 @@
+import type { RouteEndpoint, RouteLine, 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 | undefined;
+}): RouteRenderData;
+export {};
+//# sourceMappingURL=routeRenderData.d.ts.map

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

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

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

@@ -0,0 +1,14 @@
+import type { BoundingBox, 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, or `null` when
+ *   the route is empty or collapses to a single point (no useful viewport
+ *   to fit).
+ */
+export declare function computeRouteUpdate(routeLines: ReadonlyArray<RouteLine>, visibleLines: ReadonlyArray<RouteLine>): {
+    lines: RouteLine[];
+    bounds: BoundingBox | null;
+};
+//# sourceMappingURL=routeUpdate.d.ts.map

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

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

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

@@ -0,0 +1,21 @@
+import type { IconProvider } from "../adapters";
+import type { RoutePoint } from "../core";
+import type { WayfindingRenderer } from "../renderer";
+import type { FloorContext } 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

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

@@ -0,0 +1,18 @@
+import type { IconProvider } from "../adapters";
+import type { RouteLine, TransitionPointDef } from "../core";
+import type { WayfindingRenderer } from "../renderer";
+import type { FloorContext } 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

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