@expofp/floorplan 0.0.0-experimental.cf063fc

package/dist/esm/wayfinding/createWayfinding.d.ts

@@ -0,0 +1,34 @@
+import { type SceneDef } from '@expofp/renderer';
+import { type Route, type RouteEndpoint } from '@expofp/wayfinding';
+import type RootStore from '../store/RootStore';
+/** Whether `createWayfinding` has run and not yet been disposed. */
+export declare function isWayfindingReady(): boolean;
+/**
+ * Build a route between two endpoints. Throws if wayfinding is not initialized.
+ *
+ * TODO: compromise for the public SDK (`RouteStore.checkRoutes` diagnostic). Ad-hoc
+ * route building should not be a public capability — routing belongs to the runtime.
+ * Remove once the SDK surface no longer needs standalone route checks.
+ */
+export declare function buildRoute(from: RouteEndpoint, to: RouteEndpoint, options?: {
+    accessible?: boolean;
+}): Route;
+/** What {@link createWayfinding} needs: a scene to draw into, and the stores to observe. */
+export interface WayfindingOptions {
+    /** The scene wayfinding fills; its root layers hold the block `configAll` mounted. */
+    readonly scene: SceneDef;
+    /** The app store. */
+    readonly store: RootStore;
+    /** A ref holding canvas that's rendering floorplan */
+    readonly canvas: {
+        readonly current: HTMLCanvasElement | null;
+    };
+}
+/**
+ * Starts wayfinding on a `@expofp/renderer` scene: builds the engine and runtime, binds them to
+ * the stores, and declares the layout and pointer rules the renderer dispatches.
+ * @param options - The scene and the store.
+ * @returns A disposer.
+ */
+export declare function createWayfinding(options: WayfindingOptions): () => void;
+//# sourceMappingURL=createWayfinding.d.ts.map

package/dist/esm/wayfinding/createWayfinding.js

@@ -0,0 +1,183 @@
+import { getConfig } from '@expofp/config';
+import { update } from '@expofp/renderer';
+import { createWayfinding as createWayfindingInstance, resolveWayfindingLayers, } from '@expofp/wayfinding';
+import { getFpGeo } from '../data/fpGeo.js';
+import { attachCardinalSnap } from '../engine/utils/rotation';
+import { createCanvasIconProvider, createFloorContext, createGraphDataSource } from './adapters';
+import { bindMobxReactions } from './bindMobxReactions';
+import { createKioskHandler } from './handlers/kioskHandler';
+import { createYahHandler } from './handlers/yahHandler';
+/**
+ * The single active wayfinding for the current page — set by `createWayfinding`,
+ * cleared by its disposer. App-level glue: the reusable package stays stateless,
+ * so the app owns the one active instance. Assumes a single active floorplan per
+ * app (a second `createWayfinding()` replaces the first).
+ */
+let activeWayfinding = null;
+/** Whether `createWayfinding` has run and not yet been disposed. */
+export function isWayfindingReady() {
+    return activeWayfinding !== null;
+}
+function requireWayfinding() {
+    if (!activeWayfinding) {
+        throw new Error('Wayfinding is not initialized — call createWayfinding() first.');
+    }
+    return activeWayfinding;
+}
+/**
+ * Build a route between two endpoints. Throws if wayfinding is not initialized.
+ *
+ * TODO: compromise for the public SDK (`RouteStore.checkRoutes` diagnostic). Ad-hoc
+ * route building should not be a public capability — routing belongs to the runtime.
+ * Remove once the SDK surface no longer needs standalone route checks.
+ */
+export function buildRoute(from, to, options) {
+    return requireWayfinding().wayfinding.buildRoute(from, to, options);
+}
+/**
+ * Starts wayfinding on a `@expofp/renderer` scene: builds the engine and runtime, binds them to
+ * the stores, and declares the layout and pointer rules the renderer dispatches.
+ * @param options - The scene and the store.
+ * @returns A disposer.
+ */
+export function createWayfinding(options) {
+    const { scene, store, canvas } = options;
+    const layers = resolveWayfindingLayers(scene.rootLayer);
+    const { wayfinding, dispose } = start(store, layers, { attachCardinalSnap, update });
+    const iconsLayer = layers.icons;
+    // Declaring handlers is what makes a layer pickable, so this is also what keeps the rest of the
+    // block — trails, both line layers, the current position — out of raycasting entirely.
+    iconsLayer.onClick = (event) => handleIconClick(wayfinding, event);
+    iconsLayer.onPointerMove = (event) => reportHover(wayfinding, canvas, event);
+    iconsLayer.onPointerOut = () => reportHover(wayfinding, canvas);
+    update(iconsLayer);
+    return () => {
+        iconsLayer.onClick = undefined;
+        iconsLayer.onPointerMove = undefined;
+        iconsLayer.onPointerOut = undefined;
+        if (canvas.current)
+            canvas.current.style.cursor = '';
+        update(iconsLayer);
+        dispose();
+    };
+}
+/**
+ * Builds the engine, runtime and reactions, leaving the caller to wire the camera and the
+ * pointer on top.
+ * @param store - The app store.
+ * @param layers - The layers wayfinding fills.
+ * @param port - The host's roll rule and the commit function.
+ * @returns The instance and a disposer.
+ */
+function start(store, layers, port) {
+    const dataSource = createGraphDataSource(store.venueStore);
+    const wfColors = getConfig().wayfindingColors ?? {};
+    const iconProvider = createCanvasIconProvider({
+        iconMap: store.fp.icons,
+        pixelRatio: devicePixelRatio,
+        sourceColor: wfColors.source,
+        destinationColor: wfColors.destination,
+    });
+    const floorContext = createFloorContext(store.layerStore, store.routeStore, store.venueStore, dataSource);
+    const wayfinding = createWayfindingInstance({
+        dataSource,
+        renderer: port,
+        rendererConfig: {
+            colors: {
+                ...(wfColors.route && { remaining: wfColors.route }),
+                ...(wfColors.routeActive && { active: wfColors.routeActive }),
+                ...(wfColors.routePassed && { passed: wfColors.routePassed }),
+            },
+        },
+        iconProvider,
+        floorContext,
+        layers,
+        gpsConfig: getFpGeo()?.properties?.config,
+        // In 3D an icon lying on the floor reads as a smear under tilt, so every icon stands up to
+        // face the viewer. The same venue flag drives the overlay tier in `configAll`.
+        screenSpaceIcons: store.uiState.is3DView,
+        onTransitionClick: (point) => {
+            if (point.role === 'exit')
+                store.layerStore.updateVisibility(point.targetLayer, true);
+        },
+        onRouteUpdate: (lines, bounds) => {
+            store.routeStore.updateRoute([...lines], dataSource.getCampusLayers());
+            if (!bounds.isEmpty()) {
+                store.uiState.moveToRect = bounds;
+            }
+        },
+        onRouteDistance: (distance) => store.routeStore.updateRouteDistance(distance),
+    });
+    const kioskHandler = createKioskHandler({
+        wayfinding,
+        kioskIconMap: store.fp.icons,
+        floorContext,
+    });
+    const yahHandler = createYahHandler({
+        wayfinding,
+        iconMap: store.fp.icons,
+        pixelRatio: devicePixelRatio,
+        floorContext,
+    });
+    const disposeReactions = bindMobxReactions({
+        wayfinding,
+        kioskHandler,
+        yahHandler,
+        stores: { routeStore: store.routeStore, uiState: store.uiState, layerStore: store.layerStore },
+    });
+    // efp-specific toggle derived in glue (not in the package engine):
+    store.routeStore.showAccessible = dataSource.getLines().some((line) => line.unaccessible);
+    const instance = { wayfinding };
+    activeWayfinding = instance;
+    wayfinding.flush();
+    return {
+        wayfinding,
+        dispose() {
+            // Shared store state is global, so only the still-active instance may reset it.
+            if (isActive(instance)) {
+                activeWayfinding = null;
+                store.routeStore.showAccessible = false;
+                store.routeStore.markRouted(null);
+            }
+            disposeReactions();
+            wayfinding.destroy();
+        },
+    };
+}
+/**
+ * Whether an instance is still the live one — a stale disposer must not undo a newer start's work.
+ * @param instance - The registration to check.
+ * @returns Whether it is still active.
+ */
+function isActive(instance) {
+    return activeWayfinding === instance;
+}
+/**
+ * Runs a clicked wayfinding icon's callback.
+ * @param wayfinding - The instance that owns the icons.
+ * @param event - The def that was clicked.
+ */
+function handleIconClick(wayfinding, event) {
+    if (!wayfinding.handleClick([event.def]))
+        return;
+    // The icon consumed this click, so nothing underneath it should also act on it — a pin drawn over
+    // a booth must not select that booth, and a click reaching no handler at all deselects.
+    event.stopPropagation();
+}
+/**
+ * Points the cursor at a clickable wayfinding icon, and clears it again once the pointer leaves one.
+ *
+ * The canvas arrives as a ref rather than an element because the caller mounts it: a ref read at
+ * event time is current whatever React did to the canvas since, and is `null` before it mounts —
+ * which is exactly when there is nothing to point at anyway.
+ * @param wayfinding - The instance that owns the icons.
+ * @param canvas - A ref to the canvas whose cursor to set.
+ * @param event - The def under the pointer, or nothing when the pointer left one.
+ */
+function reportHover(wayfinding, canvas, event) {
+    const element = canvas.current;
+    if (!element)
+        return;
+    const hovered = event ? wayfinding.handleHover([event.def]) : false;
+    element.style.cursor = hovered ? 'pointer' : '';
+}

package/dist/esm/wayfinding/handlers/kioskHandler.d.ts

@@ -0,0 +1,26 @@
+import type { FloorContext, Wayfinding } from '@expofp/wayfinding';
+import type { Kiosk } from '../../components/Kiosk/SetKiosk';
+/**
+ * Updates the kiosk icon in response to store changes.
+ *
+ * @param kiosk  Current kiosk data, or null when kiosk mode is off.
+ */
+export type KioskHandler = (kiosk: Kiosk | null) => void;
+/**
+ * Creates a kiosk-icon handler that lives outside the wayfinding runtime.
+ *
+ * Kiosk is an efp-specific map annotation — not part of the route. Keeping it
+ * next to `createWayfinding.ts` (rather than in `runtime/`) preserves the
+ * runtime's portability: the runtime deals with source/destination/position/
+ * transitions only, and never learns that kiosks exist.
+ *
+ * On a floor-scoped plan the icon shows only while the floor the kiosk stands
+ * on is on screen (one floor on a single-venue plan, one level per venue on a
+ * multi-venue map), as `floorContext` reports it.
+ */
+export declare function createKioskHandler({ wayfinding, kioskIconMap, floorContext, }: {
+    wayfinding: Pick<Wayfinding, 'setIcon' | 'flush'>;
+    kioskIconMap: Map<string, HTMLImageElement> | undefined;
+    floorContext: FloorContext;
+}): KioskHandler;
+//# sourceMappingURL=kioskHandler.d.ts.map

package/dist/esm/wayfinding/handlers/kioskHandler.js

@@ -0,0 +1,52 @@
+import { degToRad } from '@expofp/geometry';
+import { cssSizeOf } from '../../components/Map/drawing/config/canvases';
+import { createKioskCanvas } from '../adapters';
+const KIOSK_ICON_KEY = 'kiosk';
+/**
+ * Creates a kiosk-icon handler that lives outside the wayfinding runtime.
+ *
+ * Kiosk is an efp-specific map annotation — not part of the route. Keeping it
+ * next to `createWayfinding.ts` (rather than in `runtime/`) preserves the
+ * runtime's portability: the runtime deals with source/destination/position/
+ * transitions only, and never learns that kiosks exist.
+ *
+ * On a floor-scoped plan the icon shows only while the floor the kiosk stands
+ * on is on screen (one floor on a single-venue plan, one level per venue on a
+ * multi-venue map), as `floorContext` reports it.
+ */
+export function createKioskHandler({ wayfinding, kioskIconMap, floorContext, }) {
+    // Built once per icon size and kept: `createKioskCanvas` allocates, and `setIcon` recreates the
+    // def whenever the canvas identity changes — which would discard and re-upload the icon on every
+    // kiosk update.
+    const canvasesBySize = new Map();
+    const canvasForSize = (iconSizePercent) => {
+        const key = iconSizePercent ?? 100;
+        const cached = canvasesBySize.get(key);
+        if (cached)
+            return cached;
+        const canvas = createKioskCanvas(kioskIconMap, iconSizePercent);
+        canvasesBySize.set(key, canvas);
+        return canvas;
+    };
+    return (kiosk) => {
+        const floorShown = floorContext.showAllFloors() || !kiosk?.z || floorContext.isLayerVisible(kiosk.z);
+        if (!kiosk || !floorShown) {
+            wayfinding.setIcon(KIOSK_ICON_KEY, null);
+            wayfinding.flush();
+            return;
+        }
+        const canvas = canvasForSize(kiosk.iconSizePercent);
+        wayfinding.setIcon(KIOSK_ICON_KEY, {
+            canvas,
+            ...cssSizeOf(canvas),
+            x: kiosk.x,
+            y: kiosk.y,
+            rotation: degToRad(kiosk.heading ?? 0),
+            // The heading is which way the physical device faces, so it is a direction in the venue and
+            // the marker stays flat on the plan. A screen-space def spins about the screen's normal and
+            // would point at one screen direction however the plan is turned.
+            screenSpace: false,
+        });
+        wayfinding.flush();
+    };
+}

package/dist/esm/wayfinding/handlers/yahHandler.d.ts

@@ -0,0 +1,21 @@
+import type { FloorContext, Wayfinding } from '@expofp/wayfinding';
+/**
+ * Places or hides the "You Are Here" marker. An efp-specific map annotation
+ * (shown when `routeStore.iconType !== 0` and no active route) — separated
+ * from the core runtime so the runtime never learns that YAH exists.
+ *
+ * Mutually exclusive with the runtime's position icon: `bindMobxReactions`
+ * orchestrates so that only one of the two is visible at any time.
+ */
+export type YahHandler = (position: {
+    readonly x: number;
+    readonly y: number;
+    readonly layer: string;
+} | null) => void;
+export declare function createYahHandler({ wayfinding, iconMap, pixelRatio, floorContext, }: {
+    wayfinding: Pick<Wayfinding, 'setIcon' | 'flush'>;
+    iconMap: Map<string, HTMLImageElement>;
+    pixelRatio: number;
+    floorContext: FloorContext;
+}): YahHandler;
+//# sourceMappingURL=yahHandler.d.ts.map

package/dist/esm/wayfinding/handlers/yahHandler.js

@@ -0,0 +1,42 @@
+import { createImageCanvas, createYahCanvas, cssSizeOf, } from '../../components/Map/drawing/config/canvases';
+import { decreaseByPercentage } from '../../utils/math';
+const YAH_ICON_KEY = 'yah';
+const YAH_FALLBACK_COLOR = '#ff4343';
+// Custom YAH image is drawn at 32% smaller than its native 64×90.
+const YAH_IMAGE_WIDTH = 64;
+const YAH_IMAGE_HEIGHT = 90;
+const YAH_IMAGE_SIZE_REDUCTION_PERCENT = 32;
+/**
+ * Builds the YAH canvas from the store icon map, falling back to the drawn
+ * marker. Kept here so the efp-only `'yah'` icon never leaves the handler.
+ */
+function resolveYahCanvas(iconMap, pixelRatio) {
+    const image = iconMap.get(YAH_ICON_KEY);
+    if (image) {
+        image.id = YAH_ICON_KEY;
+        return createImageCanvas(image, decreaseByPercentage(YAH_IMAGE_WIDTH, YAH_IMAGE_SIZE_REDUCTION_PERCENT), decreaseByPercentage(YAH_IMAGE_HEIGHT, YAH_IMAGE_SIZE_REDUCTION_PERCENT), pixelRatio);
+    }
+    return createYahCanvas(pixelRatio, YAH_FALLBACK_COLOR);
+}
+export function createYahHandler({ wayfinding, iconMap, pixelRatio, floorContext, }) {
+    const yahCanvas = resolveYahCanvas(iconMap, pixelRatio);
+    yahCanvas.id = 'current-location-2';
+    return (position) => {
+        if (!position) {
+            wayfinding.setIcon(YAH_ICON_KEY, null);
+            wayfinding.flush();
+            return;
+        }
+        const layerVisible = floorContext.isLayerVisible(position.layer);
+        wayfinding.setIcon(YAH_ICON_KEY, {
+            canvas: yahCanvas,
+            ...cssSizeOf(yahCanvas),
+            x: position.x,
+            y: position.y,
+            hidden: !layerVisible,
+            dimmed: !layerVisible,
+            origin: [0.5, 1],
+        });
+        wayfinding.flush();
+    };
+}

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

@@ -0,0 +1,12 @@
+/**
+ * efp-side wayfinding facade — the single entry the floorplan app imports from
+ * (stores, mount points). Re-exports the bootstrap (`createWayfinding`), the
+ * runtime facade (`isWayfindingReady`), and the glue endpoint helpers.
+ */
+export type { ArbitraryPoint } from './adapters';
+export { boothToEndpoint, CURRENT_LOCATION_NAME, CURRENT_POSITION_POINT_ID, KIOSK_ANCHOR_POINT_ID, toArbitraryPoint, } from './adapters';
+export { buildRoute } from './createWayfinding';
+export { createWayfinding, isWayfindingReady } from './createWayfinding';
+export { routeSteps } from './routeSteps';
+export type { RouteLine } from '@expofp/wayfinding';
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/wayfinding/index.js

@@ -0,0 +1,9 @@
+/**
+ * efp-side wayfinding facade — the single entry the floorplan app imports from
+ * (stores, mount points). Re-exports the bootstrap (`createWayfinding`), the
+ * runtime facade (`isWayfindingReady`), and the glue endpoint helpers.
+ */
+export { boothToEndpoint, CURRENT_LOCATION_NAME, CURRENT_POSITION_POINT_ID, KIOSK_ANCHOR_POINT_ID, toArbitraryPoint, } from './adapters';
+export { buildRoute } from './createWayfinding';
+export { createWayfinding, isWayfindingReady } from './createWayfinding';
+export { routeSteps } from './routeSteps';

package/dist/esm/wayfinding/routeSteps.d.ts

@@ -0,0 +1,15 @@
+/**
+ * The floors a route steps through, for the route panel's floor selector.
+ *
+ * A campus graph shared by several venues (see `createGraphDataSource`) labels
+ * its legs with each venue's ground level and the outdoor `WF*` layer, so a
+ * walk from hall to hall reads as a change of layer at every door. Doors are no
+ * floor change: each run of consecutive campus legs is one step, named by its
+ * first floor. Legs on layers the author drew separately keep a step each.
+ * @param layers - The route's layers in walking order, each once.
+ * @param campusLayers - The layers the campus graph's legs run on.
+ * @param isFloor - Whether a layer is a plan floor the panel can switch to.
+ * @returns The layers to list as steps.
+ */
+export declare function routeSteps(layers: readonly string[], campusLayers: ReadonlySet<string>, isFloor: (layer: string) => boolean): string[];
+//# sourceMappingURL=routeSteps.d.ts.map

package/dist/esm/wayfinding/routeSteps.js

@@ -0,0 +1,29 @@
+/**
+ * The floors a route steps through, for the route panel's floor selector.
+ *
+ * A campus graph shared by several venues (see `createGraphDataSource`) labels
+ * its legs with each venue's ground level and the outdoor `WF*` layer, so a
+ * walk from hall to hall reads as a change of layer at every door. Doors are no
+ * floor change: each run of consecutive campus legs is one step, named by its
+ * first floor. Legs on layers the author drew separately keep a step each.
+ * @param layers - The route's layers in walking order, each once.
+ * @param campusLayers - The layers the campus graph's legs run on.
+ * @param isFloor - Whether a layer is a plan floor the panel can switch to.
+ * @returns The layers to list as steps.
+ */
+export function routeSteps(layers, campusLayers, isFloor) {
+    const steps = [];
+    let campusRunStep = null;
+    for (const layer of layers) {
+        if (!campusLayers.has(layer)) {
+            campusRunStep = null;
+            steps.push(layer);
+            continue;
+        }
+        if (campusRunStep === null && isFloor(layer)) {
+            campusRunStep = layer;
+            steps.push(layer);
+        }
+    }
+    return steps;
+}

package/dist/esm/wayfinding/storePorts.d.ts

@@ -0,0 +1,67 @@
+import type { Box } from '@expofp/geometry';
+import type { Kiosk } from '../components/Kiosk/SetKiosk/types';
+import type { ArbitraryPoint } from './adapters';
+/**
+ * Structural read-model ports for {@link bindMobxReactions}.
+ *
+ * The glue only reads raw observables off the efp stores, so these are type-only
+ * shapes the concrete `RouteStore` / `UIState` / `LayerStore` satisfy structurally
+ * — the live instances pass straight through, MobX tracking is preserved, and the
+ * glue stays free of `store/*` types.
+ */
+/** Booth-shaped endpoint, narrowed to what the glue + `boothToEndpoint` read. */
+export interface BoothSource {
+    /** `number` (efp `Booth.id`) — discriminates against `ArbitraryPoint`'s string id. */
+    readonly id: number;
+    readonly rect: Box;
+    readonly rotate: number;
+    readonly layer?: {
+        readonly name: string;
+    } | null;
+    readonly innermostLayer?: {
+        readonly name: string;
+    } | null;
+}
+export type RouteEndpointSource = BoothSource | ArbitraryPoint;
+export interface RouteView {
+    readonly from: RouteEndpointSource | null;
+    readonly to: RouteEndpointSource | null;
+    readonly waypoints?: readonly BoothSource[];
+}
+/** User position the glue feeds to `positionInput` / `toArbitraryPoint`. */
+export interface PositionView {
+    readonly x: number;
+    readonly y: number;
+    readonly z?: number | string;
+    readonly angle?: number;
+}
+export interface RouteStorePort {
+    readonly currentPosition: PositionView | null;
+    readonly iconType: number;
+    readonly onlyAccessible: boolean;
+    /** Only `.length` is read (route-built recovery check). */
+    readonly routeLines: readonly unknown[];
+    readonly currentRouteLayer: {
+        readonly name: string;
+    } | null;
+    rebuildRouteFromPosition(from: ArbitraryPoint): void;
+    /** Records the route the engine has just routed, so `routeLines` are known to be its answer. */
+    markRouted(route: RouteView | null): void;
+}
+export interface UiStatePort {
+    readonly selectedRoute: RouteView | null;
+    readonly kioskData: Kiosk | null | undefined;
+    /** Reaction dependency only. */
+    readonly getRouteNextFloor: string | null;
+}
+export interface LayerStorePort {
+    /** Reaction dependency only: the kiosk handler reads floor scoping through `FloorContext`. */
+    readonly mode: number;
+    readonly layersLoaded: boolean;
+    /** Only `name` / `visible` are read (floor-change reaction dependency). */
+    readonly layers: readonly {
+        readonly name: string;
+        readonly visible: boolean;
+    }[];
+}
+//# sourceMappingURL=storePorts.d.ts.map

package/dist/esm/wayfinding/storePorts.js

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

package/package.json

@@ -0,0 +1,146 @@
+{
+  "name": "@expofp/floorplan",
+  "version": "0.0.0-experimental.cf063fc",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/expofp/efp-app.git",
+    "directory": "packages/floorplan"
+  },
+  "type": "module",
+  "description": "Interactive floor plan library for expos and events",
+  "homepage": "https://developer.expofp.com/",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "./dist/esm/index.js",
+  "module": "./dist/esm/index.js",
+  "types": "./dist/esm/index.d.ts",
+  "browser": "./dist/browser/index.js",
+  "unpkg": "./dist/browser/index.js",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "@expofp/source": "./src/index.ts",
+      "types": "./dist/esm/index.d.ts",
+      "browser": "./dist/browser/index.js",
+      "import": "./dist/esm/index.js",
+      "default": "./dist/esm/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "!**/*.tsbuildinfo",
+    "!**/*.map",
+    "!dist/stats.json"
+  ],
+  "dependencies": {
+    "@sentry/core": "^10.69.0",
+    "@sentry/react": "^10.69.0",
+    "bowser": "^2.14.1",
+    "classnames": "^2.2.6",
+    "color": "^3.1.2",
+    "color-interpolate": "^1.0.5",
+    "copy-to-clipboard": "^3.2.0",
+    "d3": "^7.3.0",
+    "d3-ease": "^3.0.1",
+    "d3-selection": "^3.0.0",
+    "dateformat": "^3.0.3",
+    "debug": "^4.4.3",
+    "deepmerge": "^4.2.2",
+    "fontfaceobserver": "^2.3.0",
+    "fuse.js": "7.3.0",
+    "history": "^4.10.1",
+    "i18next": "^19.4.4",
+    "lz-string": "^1.4.4",
+    "maplibre-gl": "^5.24.0",
+    "mobx": "^5.15.0",
+    "mobx-react-lite": "^1.5.1",
+    "ngraph.graph": "^19.1.0",
+    "particlesjs": "git+https://github.com/evgenyt1/particles.js.git",
+    "perfect-scrollbar": "^1.4.0",
+    "pmtiles": "^4.4.1",
+    "react-qr-code": "^2.0.9",
+    "react-transition-group": "^4.4.5",
+    "react-virtuoso": "^4.18.7",
+    "resize-observer": "^1.0.4",
+    "slugify": "1.6.6",
+    "stats-gl": "^3.6.0",
+    "tslib": "^2.3.0",
+    "uuid": "^9.0.1",
+    "zod": "4.4.3",
+    "@expofp/config": "0.0.0-experimental.cf063fc",
+    "@expofp/debug": "0.0.0-experimental.cf063fc",
+    "@expofp/geometry": "0.0.0-experimental.cf063fc",
+    "@expofp/renderer": "0.0.0-experimental.cf063fc",
+    "@expofp/resolve": "0.0.0-experimental.cf063fc",
+    "@expofp/schema": "0.0.0-experimental.cf063fc",
+    "@expofp/ui": "0.0.0-experimental.cf063fc",
+    "@expofp/utils": "0.0.0-experimental.cf063fc",
+    "@expofp/wayfinding": "0.0.0-experimental.cf063fc"
+  },
+  "devDependencies": {
+    "@babel/plugin-proposal-decorators": "^8.0.2",
+    "@babel/plugin-transform-class-properties": "^8.0.1",
+    "@playwright/test": "^1.62.0",
+    "@sentry/vite-plugin": "^5.4.0",
+    "@types/color": "^3.0.7",
+    "@types/d3": "^7.1.0",
+    "@types/d3-ease": "^3.0.2",
+    "@types/d3-selection": "^3.0.11",
+    "@types/dateformat": "^3.0.1",
+    "@types/history": "^4.7.11",
+    "@types/lz-string": "1.3.32",
+    "@types/react": "^19.2.17",
+    "@types/react-dom": "^19.2.3",
+    "@vitejs/plugin-react": "^6.0.4",
+    "@vitest/browser-playwright": "^4.1.10",
+    "ajv": "^8.20.0",
+    "babel-plugin-react-compiler": "^1.0.0",
+    "eslint-plugin-jsx-a11y": "^6.10.2",
+    "react": "^19.2.8",
+    "react-dom": "^19.2.8",
+    "rollup-plugin-visualizer": "^7.0.1",
+    "sass-embedded": "^1.100.0"
+  },
+  "peerDependencies": {
+    "react": "^19.2.8",
+    "react-dom": "^19.2.8"
+  },
+  "nx": {
+    "targets": {
+      "lint": {
+        "options": {
+          "fix": false
+        }
+      },
+      "minify-esm": {
+        "dependsOn": [
+          "build",
+          "typecheck"
+        ],
+        "command": "node scripts/minify-dir.js packages/floorplan/dist/esm"
+      },
+      "test-plan-swap": {
+        "dependsOn": [
+          "build-browser"
+        ],
+        "command": "playwright test --project=swap",
+        "options": {
+          "cwd": "{projectRoot}"
+        },
+        "cache": false
+      },
+      "test-plan-swap-memory": {
+        "dependsOn": [
+          "build-browser"
+        ],
+        "command": "playwright test --project=memory",
+        "options": {
+          "cwd": "{projectRoot}"
+        },
+        "cache": false
+      }
+    }
+  }
+}