@expofp/floorplan 0.0.0-experimental.2632d13

package/dist/esm/utils/loadImagesInBatches.js

@@ -0,0 +1,82 @@
+import isMobile from './is-mobile';
+import isWebview from './is-webview';
+import { loadBlob } from './loadBlob';
+import { loadImage } from './loadImage';
+const isMobileDevice = isMobile || isWebview;
+const BATCH_SIZE = isMobileDevice ? 8 : 512;
+const DELAY = isMobileDevice ? 100 : 0;
+/**
+ * Loads one id's image. It prefers the scaled variant and falls back to the full one.
+ *
+ * `normalize-legacy-data.ts` mints the preferred URL as a `__small` or `__tiny` variant by adding
+ * a suffix to the full URL, and it never confirms that the file exists. So the fallback path is
+ * not an error path. It is the normal path for any event whose logos were never rescaled.
+ * @param urls - The preferred and fallback URLs.
+ * @param load - How to load one URL. It returns null when the URL fails to load.
+ * @returns What loaded, or null when neither URL loaded.
+ */
+async function loadPreferred(urls, load) {
+    const preferred = urls.preferred ? await load(urls.preferred) : null;
+    if (preferred)
+        return preferred;
+    return urls.fallback ? load(urls.fallback) : null;
+}
+/**
+ * Loads a map of ids to images in batches, with a pause between batches.
+ *
+ * The batching exists for mobile devices. There, the function loads eight images at once, with a
+ * 100ms gap between batches, instead of loading hundreds at once. This keeps a phone's network
+ * stack and decoder from stalling the page. On desktop, it loads 512 at a time with no gap. This
+ * is, in effect, no batching at all.
+ * @param urls - The URLs to load, keyed by the caller's own id.
+ * @param load - How to load one URL.
+ * @param batchSize - How many URLs to load at once.
+ * @param delay - Milliseconds to wait between batches.
+ * @returns What loaded, keyed by id. An id is absent when its image failed to load.
+ */
+async function loadInBatchesById(urls, load, batchSize, delay) {
+    if (!urls.size)
+        return new Map();
+    const entries = Array.from(urls.entries());
+    const result = new Map();
+    for (let i = 0; i < entries.length; i += batchSize) {
+        const batch = entries.slice(i, i + batchSize);
+        const loaded = await Promise.all(batch.map(async ([id, urlsForId]) => [id, await loadPreferred(urlsForId, load)]));
+        for (const [id, value] of loaded)
+            if (value)
+                result.set(id, value);
+        if (delay)
+            await new Promise((resolve) => setTimeout(resolve, delay));
+    }
+    return result;
+}
+export async function loadImagesInBatchesById(logosUrls, batchSize = BATCH_SIZE, delay = DELAY) {
+    return loadInBatchesById(logosUrls, loadImage, batchSize, delay);
+}
+/**
+ * Loads a map of ids to image bytes. One URL loads at most once per call, no matter how many ids
+ * share it.
+ *
+ * This dedup is not an optimization. It is a correctness requirement. The renderer dedupes image
+ * sources by object identity, so two booths that share a logo must get the very same `Blob`
+ * object. If they do not, the logo downloads twice, packs twice, and draws from two atlas
+ * regions. The cache lives only for the length of this call, because the defs keep their own
+ * Blobs afterward. A cache that outlived the call would give every logo on the plan a second
+ * place to stay in memory.
+ * @param logosUrls - The URLs to load, keyed by booth id.
+ * @param batchSize - How many URLs to load at once.
+ * @param delay - Milliseconds to wait between batches.
+ * @returns The bytes, keyed by booth id. An id is absent when its logo failed to load.
+ */
+export async function loadBlobsInBatchesById(logosUrls, batchSize = BATCH_SIZE, delay = DELAY) {
+    const byUrl = new Map();
+    const load = (url) => {
+        let pending = byUrl.get(url);
+        if (!pending) {
+            pending = loadBlob(url);
+            byUrl.set(url, pending);
+        }
+        return pending;
+    };
+    return loadInBatchesById(logosUrls, load, batchSize, delay);
+}

package/dist/esm/utils/loadLayerImages.d.ts

@@ -0,0 +1,41 @@
+import { Rect } from '@expofp/geometry';
+import { type Booth } from '../store/BoothStore';
+/** One `<image>` from a layer's drawing: where it sits, and the pixels to draw there. */
+export interface LayerImage {
+    /** The booth this image belongs to, or null for a plain layer graphic. */
+    booth: Booth | null;
+    /** The image's name, when it has one. */
+    name?: string;
+    /**
+     * The bytes the renderer packs. An SVG image is rasterized and re-encoded as PNG.
+     *
+     * `createImageBitmap` rejects SVG bytes, so an SVG cannot travel to the atlas worker as it is.
+     * It stays a `Blob` all the same: a layer packs in the worker only while every one of its
+     * sources is a `Blob`, so one canvas among a layer's graphics would drop the whole layer back
+     * onto the main thread.
+     */
+    source: Blob;
+    /** Placement on the plan: the image fitted into the element's box, rotated as the element is. */
+    bounds: Rect;
+}
+/**
+ * Loads a layer's drawing images as bytes.
+ *
+ * The image is fitted into its element's box like SVG `xMidYMid meet`. The designer writes the
+ * file's pixel size into the href query as `w` and `h`. An href without a valid size is measured
+ * by decoding the image, and if that fails too, the image fills the box.
+ *
+ * Most of these hrefs are inline `data:image/webp;base64` URLs, not file references. The
+ * converter embeds designer graphics directly in the drawing payload. In a real plan, the first
+ * such image is 74KB of WebP inside a 68-unit box. `fetch` serves a `data:` URL from the browser
+ * itself, with no network call and no CORS check, and returns a Blob whose `type` matches the one
+ * the URL declares. These Blobs reach the renderer exactly as a fetched logo does, and take the
+ * same worker path. A drawing can also carry `svg-images/…` file references. `@expofp/config`
+ * rebases those to absolute URLs before this function sees them. Both forms go through `loadBlob`
+ * unchanged.
+ * @param svgImages - The `<image>` elements to load.
+ * @returns One entry per image that loaded, in element order. Images that failed to load are
+ * dropped.
+ */
+export declare function loadLayerImages(svgImages: SVGImageElement[]): Promise<LayerImage[]>;
+//# sourceMappingURL=loadLayerImages.d.ts.map

package/dist/esm/utils/loadLayerImages.js

@@ -0,0 +1,107 @@
+import { Box, degToRad, Rect } from '@expofp/geometry';
+import { blobImageSize } from './blob-image-size.js';
+import { loadBlob } from './loadBlob';
+import { isSvgBlob, svgToPngBlob } from './rasterize-svg';
+/**
+ * Loads a layer's drawing images as bytes.
+ *
+ * The image is fitted into its element's box like SVG `xMidYMid meet`. The designer writes the
+ * file's pixel size into the href query as `w` and `h`. An href without a valid size is measured
+ * by decoding the image, and if that fails too, the image fills the box.
+ *
+ * Most of these hrefs are inline `data:image/webp;base64` URLs, not file references. The
+ * converter embeds designer graphics directly in the drawing payload. In a real plan, the first
+ * such image is 74KB of WebP inside a 68-unit box. `fetch` serves a `data:` URL from the browser
+ * itself, with no network call and no CORS check, and returns a Blob whose `type` matches the one
+ * the URL declares. These Blobs reach the renderer exactly as a fetched logo does, and take the
+ * same worker path. A drawing can also carry `svg-images/…` file references. `@expofp/config`
+ * rebases those to absolute URLs before this function sees them. Both forms go through `loadBlob`
+ * unchanged.
+ * @param svgImages - The `<image>` elements to load.
+ * @returns One entry per image that loaded, in element order. Images that failed to load are
+ * dropped.
+ */
+export async function loadLayerImages(svgImages) {
+    // This map dedupes loads by URL within one call. The renderer dedupes image sources by object
+    // identity, so two elements that draw the same file must get the exact same Blob. Otherwise the
+    // file is fetched twice and packed into two atlas regions. The old code got this for free: the
+    // packer deduped image elements by their `src` string. The size is read once per file for the
+    // same reason: a decode is the expensive part.
+    const byUrl = new Map();
+    const load = (href) => {
+        let pending = byUrl.get(href);
+        if (!pending) {
+            pending = loadSource(href);
+            byUrl.set(href, pending);
+        }
+        return pending;
+    };
+    const loaded = await Promise.all(svgImages.map(async (image) => {
+        // The hrefs arrive already resolved. `@expofp/config` rebases the drawing's
+        // `svg-images/…` references when it loads the payloads.
+        const href = image.getAttribute('xlink:href') ?? image.getAttribute('href');
+        const loadedSource = href ? await load(href) : null;
+        if (!loadedSource)
+            return null;
+        const box = fitContain(Box.fromSvg(image), loadedSource.size);
+        const angle = image.transform?.animVal[0]?.angle ?? 0;
+        return {
+            bounds: Rect.fromMinMax(box.min, box.max, degToRad(angle)),
+            source: loadedSource.source,
+            booth: null,
+        };
+    }));
+    return loaded.filter((entry) => entry !== null);
+}
+/**
+ * Loads one drawing image as bytes the renderer can pack.
+ *
+ * SVG bytes are drawn into a canvas and read back as PNG. No sampled drawing references an `.svg`
+ * file today, but `collectSvgImageAssets` in `@expofp/config` filters no extension, so one can
+ * arrive.
+ * @param href - The image URL, already absolute.
+ * @returns The bytes and their size, or null when the image did not load.
+ */
+async function loadSource(href) {
+    const blob = await loadBlob(href);
+    if (!blob)
+        return null;
+    const source = isSvgBlob(blob) ? await svgToPngBlob(blob) : blob;
+    if (!source)
+        return null;
+    return { source, size: hrefImageSize(href) ?? (await blobImageSize(source)) };
+}
+/**
+ * Reads the pixel size the designer writes into an image href, as `w` and `h` query parameters.
+ * @param href - The image URL.
+ * @returns The size, or null when the href is not a URL or either parameter is missing, not a
+ * finite number, or not positive.
+ */
+function hrefImageSize(href) {
+    let params;
+    try {
+        ({ searchParams: params } = new URL(href));
+    }
+    catch {
+        return null;
+    }
+    const width = Number(params.get('w'));
+    const height = Number(params.get('h'));
+    return isPositive(width) && isPositive(height) ? { width, height } : null;
+}
+function isPositive(value) {
+    return Number.isFinite(value) && value > 0;
+}
+/**
+ * Fits an image into a box like SVG `preserveAspectRatio="xMidYMid meet"`.
+ * @param box - The box the element declares.
+ * @param size - The image's own size, or null when unknown.
+ * @returns The largest centered box with the image's aspect ratio, or `box` when the size is
+ * unknown or empty.
+ */
+function fitContain(box, size) {
+    if (!size?.width || !size.height || !box.size.width || !box.size.height)
+        return box;
+    const scale = Math.min(box.size.width / size.width, box.size.height / size.height);
+    return Box.fromCenter(box.center, { x: size.width * scale, y: size.height * scale });
+}

package/dist/esm/utils/localStorage.d.ts

@@ -0,0 +1,2 @@
+export declare const isLocalStorageAvailable: boolean;
+//# sourceMappingURL=localStorage.d.ts.map

package/dist/esm/utils/localStorage.js

@@ -0,0 +1,11 @@
+function localStorageAvailable() {
+    try {
+        localStorage.setItem('test', 'test');
+        localStorage.removeItem('test');
+        return true;
+    }
+    catch (e) {
+        return false;
+    }
+}
+export const isLocalStorageAvailable = localStorageAvailable();

package/dist/esm/utils/lz-utils.d.ts

@@ -0,0 +1,8 @@
+declare function compress(s: string): string;
+declare function decompress(s: string): string;
+declare const _default: {
+    compress: typeof compress;
+    decompress: typeof decompress;
+};
+export default _default;
+//# sourceMappingURL=lz-utils.d.ts.map

package/dist/esm/utils/lz-utils.js

@@ -0,0 +1,16 @@
+import LZString from 'lz-string';
+function compress(s) {
+    const a = LZString.compressToUint8Array(s);
+    return btoa(String.fromCharCode(...a))
+        .replace(/\+/g, '-')
+        .replace(/\//g, '_')
+        .replace(/=/g, '.');
+}
+function decompress(s) {
+    s = s.replace(/-/g, '+').replace(/_/g, '/').replace(/\./g, '=');
+    return LZString.decompressFromBase64(s);
+}
+export default {
+    compress,
+    decompress,
+};

package/dist/esm/utils/mapEntity.d.ts

@@ -0,0 +1,3 @@
+import { type FloorPlanEntity } from '../types';
+export declare function mapEntity<T extends Record<string, any>>(item: T): FloorPlanEntity | T;
+//# sourceMappingURL=mapEntity.d.ts.map

package/dist/esm/utils/mapEntity.js

@@ -0,0 +1,82 @@
+/* eslint-disable */
+import { LANGUAGE_TYPE } from '../constants';
+export function mapEntity(item) {
+    switch (item.entity.type) {
+        case 'booth':
+            return {
+                id: item.id,
+                name: getSafeString(item.name),
+                externalId: getSafeString(item.externalId),
+                isSpecial: item.entity.variant === 'special',
+                exhibitors: extractIds(item.exhibitors),
+                layer: {
+                    name: getSafeString(item.layer?.name),
+                    description: getSafeString(item.layer?.description),
+                },
+                meta: item.meta,
+                description: getSafeString(item.description),
+                entity: item.entity,
+                title: getSafeString(item.title),
+            };
+        case 'category':
+            return {
+                id: item.id,
+                name: getSafeString(item.name),
+                exhibitors: extractIds(item.exhibitors),
+                entity: item.entity,
+                slug: getSafeString(item.slug),
+            };
+        case 'exhibitor':
+            return {
+                id: item.id,
+                name: getSafeString(item.name),
+                externalId: getSafeString(item.externalId),
+                booths: extractIds(item.booths),
+                entity: item.entity,
+                slug: getSafeString(item.slug),
+            };
+        case 'schedule':
+            return {
+                id: item.id,
+                externalId: getSafeString(item.externalId),
+                boothId: item.boothId,
+                exhibitorId: item.exhibitorId,
+                name: getSafeString(item.name),
+                description: getSafeString(item.description),
+                startDate: getSafeString(item.startDate),
+                endDate: getSafeString(item.endDate),
+                link: getSafeString(item.link),
+                entity: item.entity,
+                isEnded: item.isEnded,
+            };
+        case LANGUAGE_TYPE:
+            return {
+                id: item.id,
+                name: getSafeString(item.name),
+                entity: item.entity,
+            };
+        case 'heatmap-yah':
+            return {
+                id: getSafeString(item.id),
+                name: getSafeString(item.name),
+                viewCount: item.viewCount || 0,
+                x: item.x || 0,
+                y: item.y || 0,
+                z: item.z,
+                entity: item.entity,
+            };
+        default:
+            return item;
+    }
+}
+function extractIds(list) {
+    return Array.isArray(list)
+        ? list
+            .filter(Boolean)
+            .map((e) => e.id)
+            .filter(Boolean)
+        : [];
+}
+function getSafeString(value) {
+    return typeof value === 'string' ? value : '';
+}

package/dist/esm/utils/math.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Reduces a number by a given percentage.
+ * Example: decreaseByPercentage(200, 10) → 180
+ */
+export declare function decreaseByPercentage(value: number, percentage: number): number;
+//# sourceMappingURL=math.d.ts.map

package/dist/esm/utils/math.js

@@ -0,0 +1,7 @@
+/**
+ * Reduces a number by a given percentage.
+ * Example: decreaseByPercentage(200, 10) → 180
+ */
+export function decreaseByPercentage(value, percentage) {
+    return value * (1 - percentage / 100);
+}

package/dist/esm/utils/mobx.d.ts

@@ -0,0 +1,35 @@
+import { IAutorunOptions, IReactionOptions, IReactionPublic } from 'mobx';
+import { DependencyList, EffectCallback } from 'react';
+export declare function useAutorun(view: (r: IReactionPublic) => any, opts?: IAutorunOptions): void;
+export declare function useReaction<T>(expression: (r: IReactionPublic) => T, effect: (arg: T, r: IReactionPublic) => void, opts?: IReactionOptions, deps?: DependencyList): void;
+/**
+ * Watches a **one-shot store command** — a flag the store sets and the consumer clears — from the
+ * first moment the consumer can actually act on one.
+ *
+ * Both halves of that matter, and a plain `reaction` gets both wrong for these flags:
+ *
+ * - It cannot see a command set *before* it subscribed. A reaction adopts whatever the expression
+ *   reads at subscribe time as its baseline, so such a command is never delivered and, since
+ *   nothing re-sets it, sits unhandled forever.
+ * - It would act on one set *too early*. The scene fits its space to the canvas in an effect of its
+ *   own, and React runs a parent's effects after its children's, so a consumer mounted under the
+ *   scene has no usable camera until the next frame. A command spent there is consumed and lost.
+ *
+ * Both windows are real, and the plan opens them itself: it reports `ready` from the same
+ * synchronous block that hands React the scene, so `<MapCamera>` mounts a commit after a host can
+ * first call in, and its camera is only fitted the frame after that. A host that selects a booth on
+ * `ready` lands in one window or the other depending on how loaded the machine is — the booth
+ * highlighted, and the camera never moved.
+ *
+ * So the whole subscription waits for the end of the mounting commit, and drains whatever has piled
+ * up by then.
+ * @param read - Reads the command flag.
+ * @param handle - Acts on it and clears it. Also called with the flag's cleared value, which every
+ *   handler already guards against — that is what makes each command land exactly once.
+ * @returns Disposes the watch.
+ */
+export declare function watchOneShot<T>(read: () => T, handle: (value: T) => void): () => void;
+/** {@link watchOneShot}, held for as long as the component is mounted. */
+export declare function useOneShotReaction<T>(read: () => T, handle: (value: T) => void, deps?: DependencyList): void;
+export declare function useInit(effect: EffectCallback): void;
+//# sourceMappingURL=mobx.d.ts.map

package/dist/esm/utils/mobx.js

@@ -0,0 +1,74 @@
+/* eslint-disable @typescript-eslint/no-explicit-any, @eslint-react/exhaustive-deps, @typescript-eslint/consistent-type-imports */
+import { autorun, reaction, untracked, } from 'mobx';
+import { useEffect } from 'react';
+export function useAutorun(view, opts) {
+    return useEffect(() => autorun(view, opts), []);
+}
+export function useReaction(expression, effect, opts, deps = []) {
+    return useEffect(() => reaction(expression, effect, opts), deps);
+}
+/**
+ * Runs `run` once the current React commit is over.
+ *
+ * A frame, not a microtask: the scene fits its space to the canvas in an effect of its own, and
+ * React runs a parent's effects *after* its children's — so a consumer mounted under the scene
+ * cannot see a usable camera from its own mount effect, only from the next frame.
+ * `setTimeout` is the fallback for the node test environment, which has no frames.
+ * @param run - What to run.
+ * @returns Cancels it, if it has not run yet.
+ */
+function afterCommit(run) {
+    if (typeof requestAnimationFrame === 'function') {
+        const frame = requestAnimationFrame(run);
+        return () => cancelAnimationFrame(frame);
+    }
+    const timer = setTimeout(run, 0);
+    return () => clearTimeout(timer);
+}
+/**
+ * Watches a **one-shot store command** — a flag the store sets and the consumer clears — from the
+ * first moment the consumer can actually act on one.
+ *
+ * Both halves of that matter, and a plain `reaction` gets both wrong for these flags:
+ *
+ * - It cannot see a command set *before* it subscribed. A reaction adopts whatever the expression
+ *   reads at subscribe time as its baseline, so such a command is never delivered and, since
+ *   nothing re-sets it, sits unhandled forever.
+ * - It would act on one set *too early*. The scene fits its space to the canvas in an effect of its
+ *   own, and React runs a parent's effects after its children's, so a consumer mounted under the
+ *   scene has no usable camera until the next frame. A command spent there is consumed and lost.
+ *
+ * Both windows are real, and the plan opens them itself: it reports `ready` from the same
+ * synchronous block that hands React the scene, so `<MapCamera>` mounts a commit after a host can
+ * first call in, and its camera is only fitted the frame after that. A host that selects a booth on
+ * `ready` lands in one window or the other depending on how loaded the machine is — the booth
+ * highlighted, and the camera never moved.
+ *
+ * So the whole subscription waits for the end of the mounting commit, and drains whatever has piled
+ * up by then.
+ * @param read - Reads the command flag.
+ * @param handle - Acts on it and clears it. Also called with the flag's cleared value, which every
+ *   handler already guards against — that is what makes each command land exactly once.
+ * @returns Disposes the watch.
+ */
+export function watchOneShot(read, handle) {
+    let disposeReaction;
+    const cancelStart = afterCommit(() => {
+        // Subscribed before the drain, so a command the drain's own handler provokes is not missed.
+        disposeReaction = reaction(read, (value) => handle(value));
+        // Untracked because this runs outside the reaction: reading the flag here must not enlist the
+        // caller in anything.
+        handle(untracked(read));
+    });
+    return () => {
+        cancelStart();
+        disposeReaction?.();
+    };
+}
+/** {@link watchOneShot}, held for as long as the component is mounted. */
+export function useOneShotReaction(read, handle, deps = []) {
+    return useEffect(() => watchOneShot(read, handle), deps);
+}
+export function useInit(effect) {
+    return useEffect(effect, []);
+}

package/dist/esm/utils/outdoor-poi.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Whether outdoor PoI markers are switched on for this load. Gated behind
+ * `enableExperimentalOutdoorMarkers` (unset or `false` = off), which is the one
+ * check both halves of the feature share: layer containment in
+ * `configOutdoorPoiLayer` and marker rendering in `usePoiMarkers`.
+ */
+export declare function isOutdoorMarkersEnabled(): boolean;
+/**
+ * Whether a designer layer is an Outdoor PoI layer. Name-only: the feature flag
+ * is checked by the callers, so this stays a pure predicate.
+ */
+export declare function isOutdoorPoiLayer(l: {
+    readonly name: string;
+}): boolean;
+/** The two layers a booth knows: `layer` is its top-level ancestor, `innermostLayer` the one it is drawn in. */
+interface BoothLayers {
+    readonly layer?: {
+        readonly name: string;
+    } | null;
+    readonly innermostLayer?: {
+        readonly name: string;
+    } | null;
+}
+/**
+ * Whether a booth is an outdoor PoI: drawn in an `Outdoor*` layer, with outdoor
+ * markers on (ADR-0011). Read off the layer the booth is drawn in — the one
+ * `configOutdoorPoiLayer` matched — since a plan may nest `Outdoor_Booths`
+ * inside an `_Outdoor` group, and `layer` names only that group.
+ */
+export declare function isOutdoorPoiBooth(booth: BoothLayers): boolean;
+export {};
+//# sourceMappingURL=outdoor-poi.d.ts.map

package/dist/esm/utils/outdoor-poi.js

@@ -0,0 +1,28 @@
+import { OUTDOOR_LAYER_PREFIX } from '../constants';
+import data from '../data';
+/**
+ * Whether outdoor PoI markers are switched on for this load. Gated behind
+ * `enableExperimentalOutdoorMarkers` (unset or `false` = off), which is the one
+ * check both halves of the feature share: layer containment in
+ * `configOutdoorPoiLayer` and marker rendering in `usePoiMarkers`.
+ */
+export function isOutdoorMarkersEnabled() {
+    return data.enableExperimentalOutdoorMarkers === true;
+}
+/**
+ * Whether a designer layer is an Outdoor PoI layer. Name-only: the feature flag
+ * is checked by the callers, so this stays a pure predicate.
+ */
+export function isOutdoorPoiLayer(l) {
+    return l.name.toLowerCase().startsWith(OUTDOOR_LAYER_PREFIX.toLowerCase());
+}
+/**
+ * Whether a booth is an outdoor PoI: drawn in an `Outdoor*` layer, with outdoor
+ * markers on (ADR-0011). Read off the layer the booth is drawn in — the one
+ * `configOutdoorPoiLayer` matched — since a plan may nest `Outdoor_Booths`
+ * inside an `_Outdoor` group, and `layer` names only that group.
+ */
+export function isOutdoorPoiBooth(booth) {
+    const layer = booth.innermostLayer ?? booth.layer;
+    return isOutdoorMarkersEnabled() && !!layer && isOutdoorPoiLayer(layer);
+}

package/dist/esm/utils/plan-reactions.d.ts

@@ -0,0 +1,20 @@
+import { autorun, type IReactionOptions, type IReactionPublic, type IWhenOptions } from 'mobx';
+/**
+ * `autorun`, `reaction` and `when` whose disposers belong to the live plan.
+ *
+ * A reaction created while a plan is loading stays subscribed to the store
+ * instance it first read, so one left undisposed survives
+ * `unstable_destroy()` — it pins the dead event's graph in memory and keeps
+ * writing to storage on its behalf, while never seeing the next plan
+ * (ADR-0011; spike finding in
+ * `docs/2026-08-27-plan-swap-proxy-spike-verdict.md`).
+ *
+ * Use these anywhere the plan's own construction creates a reaction: the store
+ * constructors, `store/init/*`, `floorplan.ready`, the drawing config. React
+ * components keep using plain MobX — unmount disposes them.
+ */
+export declare function planAutorun(...args: Parameters<typeof autorun>): void;
+export declare function planReaction<T>(expression: (r: IReactionPublic) => T, effect: (argument: T, r: IReactionPublic) => void, options?: IReactionOptions): void;
+/** A `when` that fires once, and is disposed unfired if the plan goes first. */
+export declare function planWhen(predicate: () => boolean, effect: () => void, options?: IWhenOptions): void;
+//# sourceMappingURL=plan-reactions.d.ts.map

package/dist/esm/utils/plan-reactions.js

@@ -0,0 +1,26 @@
+import { autorun, reaction, when, } from 'mobx';
+import { registerPlanDisposer } from '../plan-lifecycle.js';
+/**
+ * `autorun`, `reaction` and `when` whose disposers belong to the live plan.
+ *
+ * A reaction created while a plan is loading stays subscribed to the store
+ * instance it first read, so one left undisposed survives
+ * `unstable_destroy()` — it pins the dead event's graph in memory and keeps
+ * writing to storage on its behalf, while never seeing the next plan
+ * (ADR-0011; spike finding in
+ * `docs/2026-08-27-plan-swap-proxy-spike-verdict.md`).
+ *
+ * Use these anywhere the plan's own construction creates a reaction: the store
+ * constructors, `store/init/*`, `floorplan.ready`, the drawing config. React
+ * components keep using plain MobX — unmount disposes them.
+ */
+export function planAutorun(...args) {
+    registerPlanDisposer(autorun(...args));
+}
+export function planReaction(expression, effect, options) {
+    registerPlanDisposer(reaction(expression, effect, options));
+}
+/** A `when` that fires once, and is disposed unfired if the plan goes first. */
+export function planWhen(predicate, effect, options) {
+    registerPlanDisposer(when(predicate, effect, options));
+}

package/dist/esm/utils/planBearing.d.ts

@@ -0,0 +1,14 @@
+interface AnchorPoint {
+    x: number;
+    y: number;
+    lat: number;
+    lng: number;
+}
+/**
+ * Bearing (degrees, 0..360) that renders a floor plan upright on the map: the
+ * rotation from the p0->p2 anchor diagonal in plan coordinates to its direction
+ * in Web Mercator. Returns NaN for non-finite anchors.
+ */
+export declare function planBearing(p0: AnchorPoint, p2: AnchorPoint): number;
+export {};
+//# sourceMappingURL=planBearing.d.ts.map

package/dist/esm/utils/planBearing.js

@@ -0,0 +1,15 @@
+// Web Mercator northing (normalised 0..1), matching maplibre's MercatorCoordinate.
+function mercatorY(lat) {
+    return (180 - (180 / Math.PI) * Math.log(Math.tan(Math.PI / 4 + (lat * Math.PI) / 360))) / 360;
+}
+/**
+ * Bearing (degrees, 0..360) that renders a floor plan upright on the map: the
+ * rotation from the p0->p2 anchor diagonal in plan coordinates to its direction
+ * in Web Mercator. Returns NaN for non-finite anchors.
+ */
+export function planBearing(p0, p2) {
+    const mercatorAngle = Math.atan2(mercatorY(p2.lat) - mercatorY(p0.lat), (p2.lng - p0.lng) / 360);
+    const planAngle = Math.atan2(p2.y - p0.y, p2.x - p0.x);
+    const deg = (((mercatorAngle - planAngle) * 180) / Math.PI) % 360;
+    return Number.isFinite(deg) ? (deg + 360) % 360 : NaN;
+}

package/dist/esm/utils/preview-exhibitor.d.ts

@@ -0,0 +1,11 @@
+import { type RawExhibitor } from '@expofp/schema';
+/**
+ * `?__data=` / `?__lzdata=` — platform-editor glue: the exhibitor editor opens the floor plan
+ * with the draft exhibitor inlined in the URL (plain or lz-compressed JSON). Not part of the
+ * public URL grammar, stays a direct read (retirement plan §4.11).
+ *
+ * Read per call rather than at module load: a host that swaps plans changes the URL under us,
+ * and the draft exhibitor belongs to whichever event is being loaded now (ADR-0011).
+ */
+export default function getPreviewExhibitor(): RawExhibitor | null;
+//# sourceMappingURL=preview-exhibitor.d.ts.map