@expofp/wayfinding 3.11.11

package/dist/runtime/positionView.d.ts

@@ -0,0 +1,23 @@
+import { type WayfindingRenderer } from '../renderer/index.js';
+import { type IconProvider, type PositionInput } from './types.js';
+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.heading`: finite heading → 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: Pick<WayfindingRenderer, 'setIcon'>;
+    iconProvider: Pick<IconProvider, 'getIcon'>;
+    layer: string;
+}): PositionView;
+export {};
+//# sourceMappingURL=positionView.d.ts.map

package/dist/runtime/positionView.js

@@ -0,0 +1,25 @@
+import { degToRad } from '@expofp/geometry';
+export const CURRENT_POSITION_POINT_ID = 'current-position';
+const POSITION_ICON_KEY = 'position';
+export function createPositionView({ renderer, iconProvider, layer, }) {
+    return {
+        place(input, hidden) {
+            const hasHeading = Number.isFinite(input.heading);
+            const iconName = hasHeading ? 'current_arrow' : 'current';
+            const rotation = hasHeading ? degToRad(input.heading) : undefined;
+            renderer.setIcon(POSITION_ICON_KEY, {
+                canvas: iconProvider.getIcon(iconName).canvas,
+                layer,
+                x: input.x,
+                y: input.y,
+                rotation,
+                hidden,
+                dimmed: hidden,
+                origin: [0.5, 0.5],
+            });
+        },
+        hide() {
+            renderer.setIcon(POSITION_ICON_KEY, null);
+        },
+    };
+}

package/dist/runtime/routeLinesView.d.ts

@@ -0,0 +1,18 @@
+import { type RouteLine } from '../core/index.js';
+import { type WayfindingRenderer } from '../renderer/index.js';
+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: Pick<WayfindingRenderer, 'setRouteLines'>;
+    linesLayer: string;
+    animatedLinesLayer: string;
+}): RouteLinesView;
+export {};
+//# sourceMappingURL=routeLinesView.d.ts.map

package/dist/runtime/routeLinesView.js

@@ -0,0 +1,18 @@
+export function createRouteLinesView({ renderer, linesLayer, animatedLinesLayer, }) {
+    return {
+        draw({ passed, remaining }, preserveProgress = false) {
+            renderer.setRouteLines(passed, remaining, {
+                linesLayer,
+                animatedLinesLayer,
+                resetAnimation: !preserveProgress,
+            });
+        },
+        clear() {
+            renderer.setRouteLines([], [], {
+                linesLayer,
+                animatedLinesLayer,
+                resetAnimation: true,
+            });
+        },
+    };
+}

package/dist/runtime/routeRenderData.d.ts

@@ -0,0 +1,31 @@
+import { type RouteLine, type RouteSnapResult } from '../core/index.js';
+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 sliced down to the visible floor for rendering.
+ * The remaining distance is read from `snap.distance` (computed once by the
+ * runtime snap, `snapPositionToRoute`); with no snap it falls back to the full
+ * route length.
+ * @param root0
+ * @param root0.routeLines
+ * @param root0.currentRouteLayer
+ * @param root0.snap
+ */
+export declare function computeRouteRenderData({ routeLines, currentRouteLayer, snap, }: {
+    readonly routeLines: RouteLine[];
+    /** null = show-all mode; otherwise the active route floor. */
+    readonly currentRouteLayer: string | null;
+    readonly snap: RouteSnapResult | null;
+}): RouteRenderData;
+export {};
+//# sourceMappingURL=routeRenderData.d.ts.map

package/dist/runtime/routeRenderData.js

@@ -0,0 +1,46 @@
+import { getRouteLength, splitRouteByPoint, } from '../core/index.js';
+/**
+ * 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 sliced down to the visible floor for rendering.
+ * The remaining distance is read from `snap.distance` (computed once by the
+ * runtime snap, `snapPositionToRoute`); with no snap it falls back to the full
+ * route length.
+ * @param root0
+ * @param root0.routeLines
+ * @param root0.currentRouteLayer
+ * @param root0.snap
+ */
+export function computeRouteRenderData({ routeLines, currentRouteLayer, snap, }) {
+    const nonVirtualOrdered = routeLines.filter((line) => !line.virtual);
+    const clipToVisibleFloor = (lines) => currentRouteLayer === null
+        ? lines
+        : lines.filter((line) => line.p0.layer === currentRouteLayer);
+    if (!snap?.snapped) {
+        return {
+            passed: [],
+            remaining: clipToVisibleFloor(nonVirtualOrdered),
+            distance: getRouteLength(nonVirtualOrdered),
+        };
+    }
+    // Split the full route at the snap point first, then filter each side to the visible
+    // floor, so an already-passed floor renders fully as passed even when the snap is on a
+    // later floor.
+    const { passed, remaining } = splitRouteByPoint(nonVirtualOrdered, snap.snappedPoint);
+    // Ref-equal result means no segment matched the snap layer (bestIndex === -1); only on a
+    // real split do we anchor the first remaining segment at the snap point.
+    const splitOccurred = remaining !== nonVirtualOrdered;
+    // Anchor only when `remaining[0]` is on the snap's floor — at a transition it
+    // already belongs to the next floor, and keeping its own `p0` survives the clip.
+    const anchorAtSnap = splitOccurred && remaining.length > 0 && remaining[0].p0.layer === snap.snappedPoint.layer;
+    const adjustedRemaining = anchorAtSnap
+        ? [{ ...remaining[0], p0: snap.snappedPoint }, ...remaining.slice(1)]
+        : remaining;
+    return {
+        passed: clipToVisibleFloor(passed),
+        remaining: clipToVisibleFloor(adjustedRemaining),
+        distance: snap.distance,
+    };
+}

package/dist/runtime/routeUpdate.d.ts

@@ -0,0 +1,17 @@
+import { type Box } from '@expofp/geometry';
+import { type RouteLine } from '../core/index.js';
+/**
+ * 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.
+ * @param routeLines
+ * @param visibleLines
+ */
+export declare function computeRouteUpdate(routeLines: readonly RouteLine[], visibleLines: readonly RouteLine[]): {
+    lines: RouteLine[];
+    bounds: Box;
+};
+//# sourceMappingURL=routeUpdate.d.ts.map

package/dist/runtime/routeUpdate.js

@@ -0,0 +1,17 @@
+import { computeBoundingBox } from '../core/index.js';
+/**
+ * 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.
+ * @param routeLines
+ * @param visibleLines
+ */
+export function computeRouteUpdate(routeLines, visibleLines) {
+    const lines = routeLines.filter((line) => !line.virtual);
+    const points = visibleLines.flatMap((line) => [line.p0, line.p1]);
+    const bbox = computeBoundingBox(points);
+    return { lines, bounds: bbox };
+}

package/dist/runtime/snapPositionToRoute.d.ts

@@ -0,0 +1,10 @@
+import { type RouteEndpoint, type RouteLine, type RoutePoint, type RouteSnapResult } from '../core/index.js';
+/**
+ * Snap a position to the from→to route, resolving from/to booth containment
+ * first (domain logic kept out of the geometric `snapToRoute`):
+ * - inside the origin booth → route start, full distance remaining;
+ * - inside the destination booth → route end, zero remaining;
+ * - otherwise → geometric snap within `snapThreshold`.
+ */
+export declare function snapPositionToRoute(position: RoutePoint, routeLines: readonly RouteLine[], from: RouteEndpoint, to: RouteEndpoint, snapThreshold: number): RouteSnapResult;
+//# sourceMappingURL=snapPositionToRoute.d.ts.map

package/dist/runtime/snapPositionToRoute.js

@@ -0,0 +1,36 @@
+import { pointInPolygon } from '../core/geometry/pointInPolygon.js';
+import { getRouteLength, snapToRoute, } from '../core/index.js';
+/** Whether `position` lies inside `endpoint`'s booth bounds on a matching layer. */
+function insideBounds(position, endpoint, posLayer) {
+    if (!endpoint?.bounds)
+        return false;
+    const layerMatches = posLayer == null || !endpoint.layer || endpoint.layer === posLayer;
+    const containsPosition = pointInPolygon({ x: position.x, y: position.y }, endpoint.bounds);
+    return layerMatches && containsPosition;
+}
+/**
+ * Snap a position to the from→to route, resolving from/to booth containment
+ * first (domain logic kept out of the geometric `snapToRoute`):
+ * - inside the origin booth → route start, full distance remaining;
+ * - inside the destination booth → route end, zero remaining;
+ * - otherwise → geometric snap within `snapThreshold`.
+ */
+export function snapPositionToRoute(position, routeLines, from, to, snapThreshold) {
+    if (!routeLines.length)
+        return { snapped: false };
+    const posLayer = position.layer || null;
+    if (insideBounds(position, from, posLayer)) {
+        const first = routeLines[0];
+        return {
+            snapped: true,
+            snappedPoint: first.p0,
+            snappedLine: first,
+            distance: getRouteLength(routeLines),
+        };
+    }
+    if (insideBounds(position, to, posLayer)) {
+        const last = routeLines[routeLines.length - 1];
+        return { snapped: true, snappedPoint: last.p1, snappedLine: last, distance: 0 };
+    }
+    return snapToRoute(position, routeLines, { snapThreshold });
+}

package/dist/runtime/trailView.d.ts

@@ -0,0 +1,20 @@
+import { type RoutePoint } from '../core/index.js';
+import { type WayfindingRenderer } from '../renderer/index.js';
+import { type FloorContext, type IconProvider } from './types.js';
+/**
+ * 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: Pick<WayfindingRenderer, 'setTrail'>;
+    iconProvider: Pick<IconProvider, 'getIcon'>;
+    floorContext: Pick<FloorContext, 'showAllFloors' | 'getActiveFloor'>;
+    layer: string;
+}): TrailView;
+//# sourceMappingURL=trailView.d.ts.map

package/dist/runtime/trailView.js

@@ -0,0 +1,43 @@
+export function createTrailView({ renderer, iconProvider, floorContext, layer, }) {
+    const activeSlots = new Set();
+    /**
+     * Trails share one global layer (not per-floor). In scoped-floor mode the
+     * trail renders only when both endpoints lie on the active floor —
+     * otherwise the line would bleed through on unrelated floors.
+     * @param fromLayer
+     * @param toLayer
+     */
+    function isTrailVisible(fromLayer, toLayer) {
+        if (floorContext.showAllFloors())
+            return true;
+        const activeFloor = floorContext.getActiveFloor();
+        if (!activeFloor)
+            return false;
+        return fromLayer === activeFloor && toLayer === activeFloor;
+    }
+    function clearSlot(slot) {
+        renderer.setTrail(slot, null, null);
+        activeSlots.delete(slot);
+    }
+    return {
+        place(slot, from, to) {
+            if (!isTrailVisible(from.layer, to.layer)) {
+                clearSlot(slot);
+                return;
+            }
+            renderer.setTrail(slot, from, to, {
+                canvas: iconProvider.getIcon('trail').canvas,
+                layer,
+            });
+            activeSlots.add(slot);
+        },
+        clear(slot) {
+            clearSlot(slot);
+        },
+        clearAll() {
+            for (const slot of activeSlots)
+                renderer.setTrail(slot, null, null);
+            activeSlots.clear();
+        },
+    };
+}

package/dist/runtime/transitionView.d.ts

@@ -0,0 +1,17 @@
+import { type RouteLine, type TransitionPointDef } from '../core/index.js';
+import type { WayfindingRenderer } from '../renderer/index.js';
+import type { FloorContext, IconProvider } from './types.js';
+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: Pick<WayfindingRenderer, 'setIcon' | 'clearIcons'>;
+    iconProvider: Pick<IconProvider, 'getIcon'>;
+    floorContext: Pick<FloorContext, 'showAllFloors' | 'getActiveFloor' | 'getFloorOrder'>;
+    onTransitionClick: (point: TransitionPointDef) => void;
+    layer: string;
+}): TransitionView;
+export {};
+//# sourceMappingURL=transitionView.d.ts.map

package/dist/runtime/transitionView.js

@@ -0,0 +1,50 @@
+import { computeTransitionPoints } from '../core/index.js';
+const TRANSITION_ICON_NAME = 'transition';
+export function createTransitionView({ renderer, iconProvider, floorContext, onTransitionClick, layer, }) {
+    return {
+        place(routeLines) {
+            renderer.clearIcons(TRANSITION_ICON_NAME);
+            // `null` here means "don't scope to a floor" (computeTransitionPoints
+            // returns transitions for every floor). Only emit `null` in show-all
+            // mode — in scoped mode with an unresolvable active floor we must
+            // hide transitions instead of accidentally placing them on all floors.
+            let currentLayerName;
+            if (floorContext.showAllFloors()) {
+                currentLayerName = null;
+            }
+            else {
+                const activeFloor = floorContext.getActiveFloor();
+                if (!activeFloor)
+                    return;
+                currentLayerName = activeFloor;
+            }
+            const transitionPoints = computeTransitionPoints({
+                routeLines,
+                currentLayerName,
+                floorOrder: floorContext.getFloorOrder(),
+            });
+            for (const [index, point] of transitionPoints.entries()) {
+                renderer.setIcon(TRANSITION_ICON_NAME, {
+                    canvas: iconProvider.getIcon(iconNameFor(point.role, point.direction)).canvas,
+                    layer,
+                    x: point.x,
+                    y: point.y,
+                    cardinalSnap: true,
+                    onClick: point.role === 'exit' ? () => onTransitionClick(point) : undefined,
+                }, index);
+            }
+        },
+        clear() {
+            renderer.clearIcons(TRANSITION_ICON_NAME);
+        },
+    };
+}
+function iconNameFor(role, direction) {
+    if (role === 'entry')
+        return 'transition_entry';
+    if (direction === 'up')
+        return 'transition_up';
+    if (direction === 'down')
+        return 'transition_down';
+    return 'transition';
+}

package/dist/runtime/types.d.ts

@@ -0,0 +1,86 @@
+import type { Box } from '@expofp/geometry';
+import type { RouteEndpoint, RouteLine, RoutePoint, TransitionPointDef, WayfindingEngine } from '../core/index.js';
+import type { WayfindingRenderer } from '../renderer/index.js';
+export type IconName = 'source' | 'source_inactive' | 'destination' | 'current' | 'current_arrow' | 'transition' | 'transition_up' | 'transition_down' | 'transition_entry' | 'trail';
+export interface IconAsset {
+    readonly canvas: HTMLCanvasElement;
+    readonly width: number;
+    readonly height: number;
+}
+export interface IconProvider {
+    getIcon(name: IconName): IconAsset;
+}
+/** User position + optional heading, without efp store coupling. */
+export interface PositionInput {
+    readonly x: number;
+    readonly y: number;
+    readonly layer: string;
+    /** Heading in degrees. Absent → no rotation (dot variant). */
+    readonly heading?: number;
+}
+export interface LayerNames {
+    readonly points: string;
+    readonly trail: string;
+    readonly lines: string;
+    readonly linesAnimated: string;
+    readonly currentPosition: string;
+}
+export interface SetRouteInput {
+    readonly from: RouteEndpoint;
+    readonly to: RouteEndpoint;
+    readonly waypoints?: readonly RouteEndpoint[];
+    readonly accessible: boolean;
+}
+export interface WayfindingRuntime {
+    /**
+     * Build (or update) the active route. Places endpoint/transition/trail icons
+     * and fires `onRouteUpdate` + `onRouteDistance` callbacks.
+     */
+    setRoute(input: SetRouteInput): boolean;
+    /**
+     * Notify the runtime that the user position changed. `null` hides the position icon and clears
+     * the off-route trail. Dot vs arrow variant is derived from `position.heading` internally.
+     */
+    onPositionChanged(position: PositionInput | null): void;
+    /** Notify the runtime that the active floor changed; re-renders visible route content. */
+    onFloorChanged(): void;
+    /** Whether the position drifted off the active (non-virtual) route far enough to reroute. */
+    shouldReroute(position: RoutePoint): boolean;
+    clearRoute(): void;
+    destroy(): void;
+}
+export interface WayfindingRuntimeConfig {
+    readonly engine: WayfindingEngine;
+    readonly renderer: WayfindingRenderer;
+    readonly iconProvider: IconProvider;
+    readonly floorContext: FloorContext;
+    readonly layers: LayerNames;
+    readonly snapThreshold: number;
+    /** Plan-scale-aware off-route reroute distance (SVG units). */
+    readonly rerouteThreshold: number;
+    readonly onTransitionClick: (point: TransitionPointDef) => void;
+    /** Fired when the route itself changes. `bounds` is the bbox of visible route points; call `bounds.isEmpty()` to detect an empty/cleared route. */
+    readonly onRouteUpdate: (lines: readonly RouteLine[], bounds: Box) => void;
+    /** Fired when distance changes — on route change and on position snap updates. */
+    readonly onRouteDistance: (distance: number) => void;
+}
+/**
+ * Abstracts floor-state queries for the runtime.
+ *
+ * Views ask these predicates instead of reading any store directly;
+ * an adapter (see `adapters/floorContext.ts`) supplies the implementation
+ * that bridges to a concrete store (e.g., efp `LayerStore` + `RouteStore`).
+ *
+ * - {@link showAllFloors} — true when the map is rendering all floors simultaneously (no floor scoping/single-floor).
+ * - {@link getActiveFloor} — name of the active route floor, or `""` when unresolvable;
+ *   callers must check `!showAllFloors()` first.
+ * - {@link isLayerVisible} — per-layer visibility for endpoint dim/hide and cross-floor trail gating.
+ * - {@link getFloorOrder} — stable floor-name order used by transition placement.
+ */
+export interface FloorContext {
+    showAllFloors(): boolean;
+    getActiveFloor(): string;
+    isLayerVisible(layer: string): boolean;
+    getFloorOrder(): string[];
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/runtime/types.js

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

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@expofp/wayfinding",
+  "version": "3.11.11",
+  "type": "module",
+  "description": "ExpoFP SDK internal: framework-neutral wayfinding (routing, snapping, scene rendering)",
+  "homepage": "https://developer.expofp.com/",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/expofp/efp-app.git",
+    "directory": "packages/wayfinding"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "sideEffects": false,
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "@expofp/source": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "!**/*.tsbuildinfo",
+    "!**/*.map"
+  ],
+  "dependencies": {
+    "ngraph.graph": "^19.1.0",
+    "tslib": "^2.3.0",
+    "@expofp/geometry": "3.11.11"
+  },
+  "peerDependencies": {
+    "@expofp/renderer": "^3.2.4"
+  },
+  "devDependencies": {
+    "@expofp/renderer": "^3.2.4"
+  }
+}