@expofp/floorplan 0.0.0-experimental.2632d13

package/dist/esm/locales.d.ts

@@ -0,0 +1,25 @@
+declare const _default: {
+    de: string;
+    en: string;
+    es: string;
+    fr: string;
+    it: string;
+    ko: string;
+    nl: string;
+    pt: string;
+    ru: string;
+    tr: string;
+    zh: string;
+    sv: string;
+    ar: string;
+    th: string;
+    vi: string;
+    uk: string;
+    he: string;
+    kk: string;
+    pl: string;
+    mn: string;
+    da: string;
+};
+export default _default;
+//# sourceMappingURL=locales.d.ts.map

package/dist/esm/locales.js

@@ -0,0 +1,23 @@
+export default {
+    de: 'Deutsch',
+    en: 'English',
+    es: 'Español',
+    fr: 'Français',
+    it: 'Italiano',
+    ko: '한국어',
+    nl: 'Nederlands',
+    pt: 'Português',
+    ru: 'Русский',
+    tr: 'Türkçe',
+    zh: '中文',
+    sv: 'Svenska',
+    ar: 'العربية',
+    th: 'ไทย',
+    vi: 'Tiếng Việt',
+    uk: 'Українська',
+    he: 'עברית',
+    kk: 'Қазақша',
+    pl: 'Polski',
+    mn: 'Монгол',
+    da: 'Dansk',
+};

package/dist/esm/offline/constants.d.ts

@@ -0,0 +1,5 @@
+export declare const BROADCAST_CHANNEL_NAME = "EXPOFP_BROADCAST_CHANNEL_NAME";
+export declare const MESSAGE_CACHE = "EXPOFP_MESSAGE_CACHE";
+export declare const MESSAGE_REFRESH = "EXPOFP_MESSAGE_REFRESH";
+export declare const MESSAGE_CACHE_BUNDLE = "EXPOFP_MESSAGE_CACHE_BUNDLE";
+//# sourceMappingURL=constants.d.ts.map

package/dist/esm/offline/constants.js

@@ -0,0 +1,4 @@
+export const BROADCAST_CHANNEL_NAME = 'EXPOFP_BROADCAST_CHANNEL_NAME';
+export const MESSAGE_CACHE = 'EXPOFP_MESSAGE_CACHE';
+export const MESSAGE_REFRESH = 'EXPOFP_MESSAGE_REFRESH';
+export const MESSAGE_CACHE_BUNDLE = 'EXPOFP_MESSAGE_CACHE_BUNDLE';

package/dist/esm/offline/offlineManager.d.ts

@@ -0,0 +1,2 @@
+export declare function initOfflineManager(baseUrl: string, resourceUrls: string[], activationKeys?: string[]): Promise<void>;
+//# sourceMappingURL=offlineManager.d.ts.map

package/dist/esm/offline/offlineManager.js

@@ -0,0 +1,78 @@
+import isWebview from '../utils/is-webview';
+import { BROADCAST_CHANNEL_NAME, MESSAGE_CACHE, MESSAGE_CACHE_BUNDLE, MESSAGE_REFRESH, } from './constants';
+export async function initOfflineManager(baseUrl, resourceUrls, activationKeys = []) {
+    try {
+        if (!('serviceWorker' in navigator) || isWebview) {
+            return;
+        }
+        // eslint-disable-next-line compat/compat
+        const registration = await navigator.serviceWorker.getRegistration();
+        if (!registration) {
+            return;
+        }
+        if (!navigator.serviceWorker.controller) {
+            await navigator.serviceWorker.ready;
+        }
+        const channel = new BroadcastChannel(BROADCAST_CHANNEL_NAME);
+        const locks = new Set();
+        requestPersistentStorage();
+        channel.removeEventListener('message', messageHandler);
+        channel.addEventListener('message', messageHandler);
+        message({ type: MESSAGE_CACHE, payload: resourceUrls });
+        message({ type: MESSAGE_CACHE_BUNDLE, payload: buildUrl('bundle.json') });
+        refreshCache();
+        // helper functions
+        async function message(msg) {
+            const send = () => {
+                if (!navigator.serviceWorker.controller || locks.has(msg.type) || !navigator.onLine) {
+                    return;
+                }
+                channel.postMessage(msg);
+                locks.add(msg.type);
+            };
+            send();
+            if (!navigator.serviceWorker.controller) {
+                navigator.serviceWorker.addEventListener('controllerchange', send, { once: true });
+            }
+        }
+        function messageHandler(event) {
+            if (locks.has(event.data?.type) && event.data?.payload) {
+                locks.delete(event.data?.type);
+            }
+        }
+        function buildUrl(path) {
+            return baseUrl ? `${baseUrl}${path}` : path;
+        }
+        function refreshCache() {
+            if (navigator.serviceWorker.controller) {
+                const key = 'expofp_cache_refresh_ready';
+                if (localStorage.getItem(key) === '1') {
+                    message({ type: MESSAGE_REFRESH });
+                }
+                else {
+                    localStorage.setItem(key, '1');
+                }
+            }
+        }
+    }
+    catch (error) {
+        console.error(error);
+    }
+}
+function requestPersistentStorage() {
+    const key = 'expofp_persisted_storage_requested';
+    if (sessionStorage.getItem(key) || !navigator.storage) {
+        return;
+    }
+    const handler = () => {
+        navigator.storage
+            .persisted()
+            .then((isPersisted) => !isPersisted && navigator.storage.persist())
+            .catch(console.warn)
+            .finally(() => {
+            sessionStorage.setItem(key, 'true');
+            window.removeEventListener('click', handler);
+        });
+    };
+    window.addEventListener('click', handler);
+}

package/dist/esm/plan-lifecycle.d.ts

@@ -0,0 +1,65 @@
+/**
+ * The live-plan bookkeeping behind the one-live-plan-per-page contract
+ * (ADR-0011). One page shows one plan at a time; a *plan swap* is
+ * `unstable_destroy()` followed by `load()`, and the next load builds a
+ * completely fresh event-scoped world rather than resetting the old one.
+ *
+ * Two things live here, and nothing else — the module is deliberately free of
+ * store, config and DOM imports so `load()` can hold the contract without
+ * pulling the event-scoped graph into the entry chunk:
+ *
+ * - the slot: `load()` claims it and refuses a second plan; `disposePlan()`
+ *   frees it, which is what makes `unstable_destroy()` idempotent;
+ * - the teardown registry: everything the plan owns — MobX reactions, DOM
+ *   listeners, timers, the store graph itself — registers how to undo itself,
+ *   because an undisposed reaction stays subscribed to the dead instance and
+ *   pins it across the swap (spike finding, `docs/2026-08-27-plan-swap-proxy-spike-verdict.md`).
+ *
+ * Module-scope *data* that belongs to one event is not registered anywhere: it
+ * is memoized on the installed config by `tools/event-scoped-cache.ts`.
+ */
+type Disposer = () => void;
+/**
+ * What an embedder sees when their navigation code loads a second plan without
+ * destroying the first. Naming the fix is the point — the alternative is a
+ * corrupted map (ADR-0011).
+ */
+export declare const LIVE_PLAN_ERROR: string;
+/** Whether a plan currently owns the page. */
+export declare function isPlanLive(): boolean;
+/**
+ * Names the plan currently occupying the page. Bumped by every teardown, so async work started by
+ * one plan can tell that it has come back to a different one — or to none.
+ *
+ * `isPlanLive()` cannot answer that question: the next `load()` claims the slot long before
+ * `createLivePlan()` points the barrel at its graph, so a continuation resuming in that window sees
+ * a live plan and reads a barrel that is still empty. Capture this before the `await`, compare
+ * after, and drop the result when it no longer belongs to anyone (ADR-0011).
+ */
+export declare function planGeneration(): number;
+/**
+ * Reserves the page for the plan being loaded. Called at the top of `load()`,
+ * before anything is built, so a sequencing bug in the host's navigation
+ * surfaces as a rejected promise rather than a half-swapped world.
+ *
+ * @throws when a plan is already alive; the live plan is left untouched.
+ */
+export declare function claimPlanSlot(): void;
+/**
+ * Registers how to undo one thing the live plan owns. Disposers run in reverse
+ * registration order, so whatever was built first — the store graph — is the
+ * last thing to go.
+ */
+export declare function registerPlanDisposer(dispose: Disposer): void;
+/**
+ * Tears the live plan down and frees the slot: the disposer registry runs in
+ * reverse, then the page is empty again. Idempotent — a second call, and a
+ * call when nothing was ever loaded, do nothing.
+ *
+ * @throws the first failure once every disposer has run. A disposer that
+ * throws is a bug in that module, not a reason to strand the rest of the
+ * teardown and leave the page half-alive.
+ */
+export declare function disposePlan(): void;
+export {};
+//# sourceMappingURL=plan-lifecycle.d.ts.map

package/dist/esm/plan-lifecycle.js

@@ -0,0 +1,97 @@
+/**
+ * The live-plan bookkeeping behind the one-live-plan-per-page contract
+ * (ADR-0011). One page shows one plan at a time; a *plan swap* is
+ * `unstable_destroy()` followed by `load()`, and the next load builds a
+ * completely fresh event-scoped world rather than resetting the old one.
+ *
+ * Two things live here, and nothing else — the module is deliberately free of
+ * store, config and DOM imports so `load()` can hold the contract without
+ * pulling the event-scoped graph into the entry chunk:
+ *
+ * - the slot: `load()` claims it and refuses a second plan; `disposePlan()`
+ *   frees it, which is what makes `unstable_destroy()` idempotent;
+ * - the teardown registry: everything the plan owns — MobX reactions, DOM
+ *   listeners, timers, the store graph itself — registers how to undo itself,
+ *   because an undisposed reaction stays subscribed to the dead instance and
+ *   pins it across the swap (spike finding, `docs/2026-08-27-plan-swap-proxy-spike-verdict.md`).
+ *
+ * Module-scope *data* that belongs to one event is not registered anywhere: it
+ * is memoized on the installed config by `tools/event-scoped-cache.ts`.
+ */
+/**
+ * What an embedder sees when their navigation code loads a second plan without
+ * destroying the first. Naming the fix is the point — the alternative is a
+ * corrupted map (ADR-0011).
+ */
+export const LIVE_PLAN_ERROR = 'A plan is already loaded on this page; call destroy() first ' +
+    '(one live plan per page — see the Switching plans guide).';
+let planLive = false;
+// Monotonic: only ever incremented, so no two plans on a page share a value.
+let generation = 0;
+const disposers = [];
+/** Whether a plan currently owns the page. */
+export function isPlanLive() {
+    return planLive;
+}
+/**
+ * Names the plan currently occupying the page. Bumped by every teardown, so async work started by
+ * one plan can tell that it has come back to a different one — or to none.
+ *
+ * `isPlanLive()` cannot answer that question: the next `load()` claims the slot long before
+ * `createLivePlan()` points the barrel at its graph, so a continuation resuming in that window sees
+ * a live plan and reads a barrel that is still empty. Capture this before the `await`, compare
+ * after, and drop the result when it no longer belongs to anyone (ADR-0011).
+ */
+export function planGeneration() {
+    return generation;
+}
+/**
+ * Reserves the page for the plan being loaded. Called at the top of `load()`,
+ * before anything is built, so a sequencing bug in the host's navigation
+ * surfaces as a rejected promise rather than a half-swapped world.
+ *
+ * @throws when a plan is already alive; the live plan is left untouched.
+ */
+export function claimPlanSlot() {
+    if (planLive)
+        throw new Error(LIVE_PLAN_ERROR);
+    planLive = true;
+}
+/**
+ * Registers how to undo one thing the live plan owns. Disposers run in reverse
+ * registration order, so whatever was built first — the store graph — is the
+ * last thing to go.
+ */
+export function registerPlanDisposer(dispose) {
+    disposers.push(dispose);
+}
+/**
+ * Tears the live plan down and frees the slot: the disposer registry runs in
+ * reverse, then the page is empty again. Idempotent — a second call, and a
+ * call when nothing was ever loaded, do nothing.
+ *
+ * @throws the first failure once every disposer has run. A disposer that
+ * throws is a bug in that module, not a reason to strand the rest of the
+ * teardown and leave the page half-alive.
+ */
+export function disposePlan() {
+    if (!planLive)
+        return;
+    planLive = false;
+    generation++;
+    let failure;
+    let failed = false;
+    while (disposers.length > 0) {
+        try {
+            disposers.pop()();
+        }
+        catch (error) {
+            if (!failed) {
+                failure = error;
+                failed = true;
+            }
+        }
+    }
+    if (failed)
+        throw failure;
+}

package/dist/esm/schemas/sdk.schemas.d.ts

@@ -0,0 +1,25 @@
+import * as z from 'zod/mini';
+export declare const BoundsSchema: z.ZodMiniObject<{
+    leftTop: z.ZodMiniObject<{
+        x: z.ZodMiniNumber<number>;
+        y: z.ZodMiniNumber<number>;
+    }, z.core.$strict>;
+    rightBottom: z.ZodMiniObject<{
+        x: z.ZodMiniNumber<number>;
+        y: z.ZodMiniNumber<number>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const POISelectorsSchema: z.ZodMiniObject<{
+    booths: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniObject<{
+        name: z.ZodMiniOptional<z.ZodMiniString<string>>;
+        externalId: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    }, z.core.$strict>>>;
+    exhibitors: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniObject<{
+        name: z.ZodMiniOptional<z.ZodMiniString<string>>;
+        externalId: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
+export declare const ZoomToOptionsSchema: z.ZodMiniOptional<z.ZodMiniObject<{
+    padding: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+}, z.core.$strict>>;
+//# sourceMappingURL=sdk.schemas.d.ts.map

package/dist/esm/schemas/sdk.schemas.js

@@ -0,0 +1,24 @@
+import * as z from 'zod/mini';
+const PointSchema = z.strictObject({
+    x: z.number(),
+    y: z.number(),
+});
+export const BoundsSchema = z.strictObject({
+    leftTop: PointSchema,
+    rightBottom: PointSchema,
+});
+const POISelectorSchema = z
+    .strictObject({
+    name: z.optional(z.string()),
+    externalId: z.optional(z.string()),
+})
+    .check(z.refine((data) => !!(data.name || data.externalId), 'Either name or externalId must be provided'));
+export const POISelectorsSchema = z
+    .strictObject({
+    booths: z.optional(z.array(POISelectorSchema)),
+    exhibitors: z.optional(z.array(POISelectorSchema)),
+})
+    .check(z.refine((data) => !!(data.booths?.length || data.exhibitors?.length), 'Selector must contain booths or exhibitors'));
+export const ZoomToOptionsSchema = z.optional(z.strictObject({
+    padding: z.optional(z.number()),
+}));

package/dist/esm/services/URLFilterManager.d.ts

@@ -0,0 +1,39 @@
+import type RootStore from '../store/RootStore';
+import { type URLFilters } from '../store/types';
+export declare class URLFilterManager {
+    private rootStore;
+    currentFilters: URLFilters;
+    isInitialized: boolean;
+    constructor(rootStore: RootStore);
+    initialize(): void;
+    private parseURLFilters;
+    /**
+     * The raw filter values, before catalog validation. The canonical
+     * `config.filters` node wins when present (`?filters[categories][0]=food` or
+     * any config layer; values are plain names, no custom decoding).
+     */
+    private readRawFilters;
+    private applyFiltersToStore;
+    /**
+     * The active filters' contribution to `location.search` — `''` when no
+     * filter is active, else `'?<legacy filter keys>'`, byte-identical to what
+     * `updateURLFromFilters` writes. Also read by the URL autorun (url-dispatch):
+     * when nothing else claims the URL, the filter query IS the selection. Both
+     * writers must emit the same string — emitting different ones made their
+     * MobX ordering decide the final address bar (the poiType-clearing race).
+     */
+    filterSearch(): string;
+    updateURLFromFilters(): void;
+    setCategories(categoryNames: string[]): void;
+    setPoiType(poiTypeName: string | null): void;
+    setPoiTypes(poiTypeNames: string[]): void;
+    clearAllFilters(): void;
+    getCurrentFilters(): URLFilters;
+    private setupReactions;
+    validateFilters(filters: URLFilters): boolean;
+    private getCategoryIdByName;
+    private getPoiTypeIdByName;
+    private focusOnFilteredBooths;
+    private openExhibitorsList;
+}
+//# sourceMappingURL=URLFilterManager.d.ts.map