@expofp/floorplan 0.0.0-experimental.2d6c681

package/dist/esm/store/venue-public.d.ts

@@ -0,0 +1,10 @@
+import type { Venue as PublicVenue } from '../types';
+import type { Venue } from './VenueStore';
+/**
+ * The single `Venue` → public-contract projection, shared by `getFloorPlan().getVenues()`
+ * and the `onVenueActivated` payload so a new contract field is added in one place.
+ * Type-only imports keep this a leaf module the SDK facade can use without
+ * loading the store graph.
+ */
+export declare function toPublicVenue(venue: Venue, active: boolean): PublicVenue;
+//# sourceMappingURL=venue-public.d.ts.map

package/dist/esm/store/venue-public.js

@@ -0,0 +1,14 @@
+/**
+ * The single `Venue` → public-contract projection, shared by `getFloorPlan().getVenues()`
+ * and the `onVenueActivated` payload so a new contract field is added in one place.
+ * Type-only imports keep this a leaf module the SDK facade can use without
+ * loading the store graph.
+ */
+export function toPublicVenue(venue, active) {
+    return {
+        id: venue.id,
+        name: venue.name,
+        order: venue.order,
+        active,
+    };
+}

package/dist/esm/store/venue-selection.d.ts

@@ -0,0 +1,45 @@
+import type VenueStore from './VenueStore';
+interface BoothWithLayer {
+    layer?: {
+        name: string;
+    } | null;
+}
+interface VenueLayerEntryOptions {
+    fly?: boolean;
+}
+interface VenueMessageSource {
+    readonly hasVenueModel: boolean;
+    venueOfLayer(layerName: string): {
+        name: string;
+    } | null;
+}
+/** Establishes one venue-and-level destination when a layer belongs to the venue model. */
+export declare function enterVenueForLayer(venueStore: VenueStore, layerName: string, options?: VenueLayerEntryOptions): boolean;
+/**
+ * Resolves URL or restored venue/level settings into one deliberate
+ * destination. `?camera[venue]=` carries a venue `id` (contract §9); a display
+ * name resolves nothing and leaves the level setting to decide.
+ */
+export declare function enterVenueFromMapSettings(venueStore: VenueStore, venueId?: string, layerName?: string): boolean;
+/**
+ * Venue-model selection focus-follow (KTD-7/KTD-8): selecting booths in
+ * another venue moves the focus and activates the booths' level state-only —
+ * no camera writes, because the existing booth camera reaction owns the fly.
+ * No-op unless every booth sits on the same venue level (cross-layer
+ * selections keep today's behavior).
+ */
+export declare function focusVenueForBooths(venueStore: VenueStore, booths: readonly BoothWithLayer[]): Promise<void> | undefined;
+export declare function getCrossVenueRouteNotFoundMessage(venueStore: VenueMessageSource, fromLayerName: string | undefined, toLayerName: string | undefined, notConnectedLabel: string): string | undefined;
+interface SearchCameraBooth extends BoothWithLayer {
+    visible: boolean;
+}
+type SearchCameraVenueSource = Pick<VenueStore, 'hasVenueModel' | 'focusedVenue' | 'venueOfLayer'>;
+/**
+ * What the camera frames while the visitor types in search (`searchCameraFollow`): the matches in
+ * the venue on screen, else the matches when they all share one venue (or all sit outside every
+ * venue), else nothing. Matches spread over levels keep the shown level, or else the first match's
+ * level, so the camera never needs two levels at once. `null` leaves the camera where it is.
+ */
+export declare function pickSearchCameraBooths<T extends SearchCameraBooth>(venueStore: SearchCameraVenueSource, booths: readonly T[]): T[] | null;
+export {};
+//# sourceMappingURL=venue-selection.d.ts.map

package/dist/esm/store/venue-selection.js

@@ -0,0 +1,101 @@
+function getCommonLayerName(booths) {
+    const layerName = booths[0]?.layer?.name;
+    if (!layerName || booths.some((booth) => booth.layer?.name !== layerName))
+        return null;
+    return layerName;
+}
+/** Establishes one venue-and-level destination when a layer belongs to the venue model. */
+export function enterVenueForLayer(venueStore, layerName, options = {}) {
+    if (!venueStore.hasVenueModel)
+        return false;
+    const venue = venueStore.venueOfLayer(layerName);
+    const level = venue?.levels.find((candidate) => candidate.layer.name === layerName);
+    if (!venue || !level)
+        return false;
+    venueStore.enterVenue(venue, { ...options, level });
+    return true;
+}
+/**
+ * Resolves URL or restored venue/level settings into one deliberate
+ * destination. `?camera[venue]=` carries a venue `id` (contract §9); a display
+ * name resolves nothing and leaves the level setting to decide.
+ */
+export function enterVenueFromMapSettings(venueStore, venueId, layerName) {
+    if (!venueStore.hasVenueModel)
+        return false;
+    const explicitVenue = venueId ? venueStore.findVenue(venueId) : null;
+    if (explicitVenue) {
+        const level = layerName
+            ? explicitVenue.levels.find((candidate) => candidate.layer.name === layerName)
+            : undefined;
+        if (level)
+            venueStore.enterVenue(explicitVenue, { level });
+        else
+            venueStore.enterVenue(explicitVenue);
+        return true;
+    }
+    return layerName ? enterVenueForLayer(venueStore, layerName) : false;
+}
+/**
+ * Venue-model selection focus-follow (KTD-7/KTD-8): selecting booths in
+ * another venue moves the focus and activates the booths' level state-only —
+ * no camera writes, because the existing booth camera reaction owns the fly.
+ * No-op unless every booth sits on the same venue level (cross-layer
+ * selections keep today's behavior).
+ */
+export function focusVenueForBooths(venueStore, booths) {
+    if (!venueStore.hasVenueModel || booths.length === 0)
+        return;
+    const venues = booths.map((booth) => booth.layer?.name ? venueStore.venueOfLayer(booth.layer.name) : null);
+    const venue = venues[0];
+    if (!venue || venues.some((candidate) => candidate !== venue))
+        return;
+    const layerName = getCommonLayerName(booths);
+    if (layerName) {
+        const level = venue.levels.find((candidate) => candidate.layer.name === layerName);
+        return level ? venueStore.enterVenue(venue, { fly: false, level }) : undefined;
+    }
+    return venueStore.enterVenue(venue, { fly: false });
+}
+export function getCrossVenueRouteNotFoundMessage(venueStore, fromLayerName, toLayerName, notConnectedLabel) {
+    if (!venueStore.hasVenueModel || !fromLayerName || !toLayerName)
+        return undefined;
+    const fromVenue = venueStore.venueOfLayer(fromLayerName);
+    const toVenue = venueStore.venueOfLayer(toLayerName);
+    return fromVenue && toVenue && fromVenue !== toVenue
+        ? `${fromVenue.name} \u2194 ${toVenue.name}: ${notConnectedLabel}`
+        : undefined;
+}
+/**
+ * What the camera frames while the visitor types in search (`searchCameraFollow`): the matches in
+ * the venue on screen, else the matches when they all share one venue (or all sit outside every
+ * venue), else nothing. Matches spread over levels keep the shown level, or else the first match's
+ * level, so the camera never needs two levels at once. `null` leaves the camera where it is.
+ */
+export function pickSearchCameraBooths(venueStore, booths) {
+    if (!venueStore.hasVenueModel) {
+        const shown = booths.filter((booth) => booth.visible);
+        return shown.length ? shown : null;
+    }
+    const venueOf = (booth) => booth.layer?.name ? venueStore.venueOfLayer(booth.layer.name) : null;
+    const focused = venueStore.focusedVenue;
+    let targets = focused ? booths.filter((booth) => venueOf(booth) === focused) : [];
+    if (!targets.length) {
+        if (!booths.length)
+            return null;
+        const venue = venueOf(booths[0]);
+        if (booths.some((booth) => venueOf(booth) !== venue))
+            return null;
+        // Outside every venue (outdoor points on the campus): only what is drawn can be framed.
+        if (!venue) {
+            const shown = booths.filter((booth) => booth.visible);
+            return shown.length ? shown : null;
+        }
+        targets = [...booths];
+    }
+    const shown = targets.filter((booth) => booth.visible);
+    if (shown.length)
+        return shown;
+    const layerName = targets[0].layer?.name;
+    return targets.filter((booth) => booth.layer?.name === layerName);
+}

package/dist/esm/test/store-harness.d.ts

@@ -0,0 +1,32 @@
+/**
+ * @file Builds store instances under jsdom. Specs using this helper must
+ * declare `// @vitest-environment jsdom` (a forgotten pragma surfaces as
+ * `HTMLCanvasElement is not defined` from inside this file). Every stub below
+ * exists because removing it breaks the import or the constructor — nothing is
+ * mocked pre-emptively.
+ */
+type UIStateInstance = InstanceType<typeof import('../store/UIState.js').default>;
+/** Constructs a `UIState` on a fake `RootStore`. `overrides` extends that fake. */
+export declare function createUIState(overrides?: Record<string, unknown>): Promise<import("../store/UIState.js").default>;
+/** Constructs a `RouteStore` next to a real `UIState`; route-side siblings are faked. */
+export declare function createRouteStore(overrides?: Record<string, unknown>): Promise<{
+    routeStore: import("../store/RouteStore.js").default;
+    uiState: UIStateInstance;
+    rootStore: Record<string, unknown>;
+    Route: typeof import("../store/RouteStore.js").Route;
+}>;
+/**
+ * Constructs a `SearchButtonsStore` beside a real `RouteStore`,
+ * `RoutePlannerStore` and `URLFilterManager`; the rest of the store graph is faked.
+ */
+export declare function createSearchButtonsStore(overrides?: Record<string, unknown>): Promise<{
+    searchButtonsStore: import("../store/SearchButtonsStore.js").default;
+    routePlannerStore: import("../store/RoutePlannerStore.js").default;
+    routeStore: import("../store/RouteStore.js").default;
+    urlFilterManager: import("../services/URLFilterManager.js").URLFilterManager;
+    uiState: import("../store/UIState.js").default;
+    rootStore: Record<string, unknown>;
+    Route: typeof import("../store/RouteStore.js").Route;
+}>;
+export {};
+//# sourceMappingURL=store-harness.d.ts.map

package/dist/esm/test/store-harness.js

@@ -0,0 +1,116 @@
+/**
+ * @file Builds store instances under jsdom. Specs using this helper must
+ * declare `// @vitest-environment jsdom` (a forgotten pragma surfaces as
+ * `HTMLCanvasElement is not defined` from inside this file). Every stub below
+ * exists because removing it breaks the import or the constructor — nothing is
+ * mocked pre-emptively.
+ */
+import { setConfig } from '@expofp/config';
+import { vi } from 'vitest';
+/** Backs the mocked store-barrel singleton; holds the most recently built instance. */
+let currentUIState = {};
+/** Backs the barrel's default export (`store`), the same way: the most recently built root. */
+let currentRootStore = {};
+/** Builds a fake `RootStore` carrying a real `UIState`. `overrides` extends it. */
+async function createStores(overrides = {}) {
+    prepareStoreModules();
+    const { default: UIState } = await import('../store/UIState.js');
+    const rootStore = { fp: {}, ...overrides };
+    // In production the barrel singleton and `this` are the same object.
+    rootStore.uiState = currentUIState = new UIState(rootStore);
+    currentRootStore = rootStore;
+    return rootStore;
+}
+/** Constructs a `UIState` on a fake `RootStore`. `overrides` extends that fake. */
+export async function createUIState(overrides = {}) {
+    const rootStore = await createStores(overrides);
+    return rootStore.uiState;
+}
+/** Constructs a `RouteStore` next to a real `UIState`; route-side siblings are faked. */
+export async function createRouteStore(overrides = {}) {
+    const rootStore = await createStores({
+        fp: {},
+        moveToList: vi.fn(),
+        showMap: vi.fn(),
+        layerStore: { layers: [], updateVisibility: vi.fn(), findLayer: vi.fn(() => null) },
+        // `selectRoute` asks whether the destination sits in a venue before it moves
+        // the camera; without a venue model it never reaches the rest of the store.
+        venueStore: {
+            hasVenueModel: false,
+            venueOfLayer: vi.fn(() => null),
+            enterVenue: vi.fn(),
+            frameActiveVenue: vi.fn(() => false),
+        },
+        ...overrides,
+    });
+    const { default: RouteStore, Route } = await import('../store/RouteStore.js');
+    const routeStore = new RouteStore(rootStore);
+    rootStore.routeStore = routeStore;
+    return {
+        routeStore,
+        uiState: rootStore.uiState,
+        rootStore,
+        Route,
+    };
+}
+/**
+ * Constructs a `SearchButtonsStore` beside a real `RouteStore`,
+ * `RoutePlannerStore` and `URLFilterManager`; the rest of the store graph is faked.
+ */
+export async function createSearchButtonsStore(overrides = {}) {
+    const { routeStore, uiState, rootStore, Route } = await createRouteStore({
+        fp: { hidePathways: vi.fn(), getOptimizedRoutes: () => [] },
+        boothStore: { booths: [] },
+        poiTypeStore: { poiTypes: [] },
+        categoryFilterStore: { state: { selectedItems: [], pendingItems: [] }, openFilter: vi.fn() },
+        searchStore: { selectSearchAndFocus: vi.fn(), setFocused: vi.fn() },
+        ...overrides,
+    });
+    const { default: RoutePlannerStore } = await import('../store/RoutePlannerStore.js');
+    const { URLFilterManager } = await import('../services/URLFilterManager.js');
+    const { default: SearchButtonsStore } = await import('../store/search-buttons/SearchButtonsStore.js');
+    const routePlannerStore = new RoutePlannerStore(rootStore);
+    rootStore.routePlannerStore = routePlannerStore;
+    const searchButtonsStore = new SearchButtonsStore(rootStore);
+    rootStore.searchButtonsStore = searchButtonsStore;
+    const urlFilterManager = new URLFilterManager(rootStore);
+    rootStore.urlFilterManager = urlFilterManager;
+    return {
+        searchButtonsStore,
+        routePlannerStore,
+        routeStore,
+        urlFilterManager,
+        uiState,
+        rootStore,
+        Route,
+    };
+}
+/**
+ * Seeds and mocks everything the store modules touch while loading. Mocks are
+ * `vi.doMock`, so store modules must be reached via dynamic `import()` — never
+ * statically imported by a spec. Deliberately no `vi.resetModules()`: a reset
+ * registry hands the stores a different `@expofp/config` instance.
+ */
+function prepareStoreModules() {
+    // `tools/settings` reads this at module level.
+    window.__efpEvent = 'demo';
+    // The renderer takes a 2d context at module level.
+    HTMLCanvasElement.prototype.getContext = (() => new Proxy({}, { get: () => () => undefined }));
+    // Without this an import of UIState builds an entire real RootStore.
+    vi.doMock('../store/index.js', () => ({
+        get default() {
+            return currentRootStore;
+        },
+        get uiState() {
+            return currentUIState;
+        },
+    }));
+    vi.doMock('../data/svg.js', () => ({ svgArea: () => null, svgAreaExplicit: () => null }));
+    vi.doMock('../tools/gtag.js', () => ({
+        hasUserConsent: () => false,
+        sendEventToGa: vi.fn(),
+        GaEventActions: {},
+    }));
+    // `data/fpGeo` reads the drawing payload at module level; a plain object is enough.
+    setConfig({ fpSvgJsRef: {}, fpSvgLayerJsRefs: {} });
+}

package/dist/esm/tools/base-runtime-url.d.ts

@@ -0,0 +1,3 @@
+declare let baseUrl: string;
+export default baseUrl;
+//# sourceMappingURL=base-runtime-url.d.ts.map

package/dist/esm/tools/base-runtime-url.js

@@ -0,0 +1,23 @@
+/// <reference types="vite/client" />
+let baseUrl;
+if (import.meta.env?.DEV) {
+    // Vite dev: serve from the configured base (defaults to "/")
+    const base = import.meta.env.BASE_URL || '/';
+    baseUrl = new URL(base, window.location.origin).href;
+}
+else {
+    // Production: directory of the built script file
+    baseUrl = new URL(/* @vite-ignore */ '.', import.meta.url).href;
+}
+// Ensure trailing slash
+if (!baseUrl.endsWith('/'))
+    baseUrl += '/';
+// /* @vite-ignore */
+// console.log(
+//   'base-url.ts',
+//   baseUrl,
+//   import.meta.env?.DEV,
+//   import.meta.env.BASE_URL,
+//   import.meta.url,
+// );
+export default baseUrl;

package/dist/esm/tools/debounce.d.ts

@@ -0,0 +1,2 @@
+export default function debounce<Params extends any[]>(func: (...args: Params) => any, timeoutMs: number): (...args: Params) => void;
+//# sourceMappingURL=debounce.d.ts.map

package/dist/esm/tools/debounce.js

@@ -0,0 +1,10 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+export default function debounce(func, timeoutMs) {
+    let timer;
+    return (...args) => {
+        clearTimeout(timer);
+        timer = setTimeout(() => {
+            func(...args);
+        }, timeoutMs);
+    };
+}

package/dist/esm/tools/debugCanvases.d.ts

@@ -0,0 +1,3 @@
+declare const debugCanvases: any[];
+export default debugCanvases;
+//# sourceMappingURL=debugCanvases.d.ts.map

package/dist/esm/tools/debugCanvases.js

@@ -0,0 +1,3 @@
+// @ts-nocheck
+const debugCanvases = [];
+export default debugCanvases;

package/dist/esm/tools/event-not-found.d.ts

@@ -0,0 +1,18 @@
+/**
+ * "Event not found" fallback shown when the config fails to load.
+ *
+ * `loadConfig` fetches the event's data document (`data.js`); if that 404s or
+ * fails validation the event data is missing and the floor plan cannot
+ * initialize. Instead of leaving a blank or
+ * half-broken view, we render a short message inside the target element, centered
+ * within whatever box it already occupies — full-screen on a standalone page, or
+ * the integrator's container when embedded — so it never escapes the host page's
+ * layout. (That containment is why no host check is needed.)
+ *
+ * Deliberately plain-DOM (no React/MobX) so it works even though the floor plan
+ * never booted, and it avoids flex `gap` (unsupported on the SDK's old-WebView
+ * targets, e.g. chrome66) — the subtitle uses a margin instead.
+ */
+/** Renders a centered "Event not found" message inside the target element. */
+export declare function showEventNotFound(element: HTMLElement): void;
+//# sourceMappingURL=event-not-found.d.ts.map

package/dist/esm/tools/event-not-found.js

@@ -0,0 +1,50 @@
+/**
+ * "Event not found" fallback shown when the config fails to load.
+ *
+ * `loadConfig` fetches the event's data document (`data.js`); if that 404s or
+ * fails validation the event data is missing and the floor plan cannot
+ * initialize. Instead of leaving a blank or
+ * half-broken view, we render a short message inside the target element, centered
+ * within whatever box it already occupies — full-screen on a standalone page, or
+ * the integrator's container when embedded — so it never escapes the host page's
+ * layout. (That containment is why no host check is needed.)
+ *
+ * Deliberately plain-DOM (no React/MobX) so it works even though the floor plan
+ * never booted, and it avoids flex `gap` (unsupported on the SDK's old-WebView
+ * targets, e.g. chrome66) — the subtitle uses a margin instead.
+ */
+import { markNotIndexable } from '../utils/event-head';
+import isOwnDomain from '../utils/is-own-domain';
+/** Renders a centered "Event not found" message inside the target element. */
+export function showEventNotFound(element) {
+    if (typeof document === 'undefined' || !element)
+        return;
+    // On our own hosts this screen IS the page — keep it out of the index. An
+    // embed's host page is not ours to deindex.
+    if (isOwnDomain)
+        markNotIndexable(document);
+    // Reuse the target element as the message container and center the content
+    // inside it. We do not touch position/size — the element keeps its own
+    // layout, so the message stays within the target element (and embedded
+    // containers are not taken over).
+    element.textContent = '';
+    const s = element.style;
+    s.display = 'flex';
+    s.flexDirection = 'column';
+    s.alignItems = 'center';
+    s.justifyContent = 'center';
+    s.boxSizing = 'border-box';
+    s.padding = '24px';
+    s.background = '#ffffff';
+    s.color = '#1f2937';
+    s.textAlign = 'center';
+    s.fontFamily = 'Inter, system-ui, -apple-system, "Segoe UI", Roboto, sans-serif';
+    const title = document.createElement('div');
+    title.textContent = 'Event not found';
+    title.style.cssText = ['font-size: 28px', 'font-weight: 600', 'line-height: 1.25'].join('; ');
+    const subtitle = document.createElement('div');
+    subtitle.textContent = 'This event does not exist or is no longer available.';
+    subtitle.style.cssText = ['margin-top: 8px', 'font-size: 16px', 'color: #6b7280'].join('; ');
+    element.appendChild(title);
+    element.appendChild(subtitle);
+}

package/dist/esm/tools/event-scoped-cache.d.ts

@@ -0,0 +1,13 @@
+/**
+ * A value derived from the live event, built on first read and again on the
+ * first read after a new config is installed. Use it for state that has to be
+ * a single mutable object for the lifetime of one plan (the kind a plain
+ * function returning a fresh object each call cannot serve).
+ *
+ * @param build Produces the value for the event that is live when it runs.
+ * @returns A getter for the live event's value.
+ */
+export declare function eventScopedValue<T>(build: () => T): () => T;
+/** A `Map` that starts empty for every plan. */
+export declare function eventScopedCache<K, V>(): () => Map<K, V>;
+//# sourceMappingURL=event-scoped-cache.d.ts.map

package/dist/esm/tools/event-scoped-cache.js

@@ -0,0 +1,47 @@
+/**
+ * Module-level state that belongs to a single event (ADR-0011). A module body
+ * evaluates once per page, so a plain `const cache = new Map()` fills with the
+ * first event's objects and is read back beside the second event's config
+ * (`docs/2026-08-26-multi-event-teardown-diagnosis.md`). The values built here
+ * are keyed by the installed config object instead: `load()` installs a fresh
+ * one per plan, and the first read after that rebuilds. Nothing has to be
+ * registered, swept or ordered.
+ *
+ * Two consequences of keying on the config rather than sweeping:
+ *
+ * - the dead window between `destroy()` and the next `load()` still holds the
+ *   previous config, so a read there serves the previous event's value — the
+ *   same as the `data` document itself;
+ * - the previous value is released on the first read under the new config,
+ *   not at the swap. A value the next plan never reads keeps the previous
+ *   plan's objects (and whatever they reference) alive until a later plan
+ *   reads it. Memory only — nothing ever observes it stale.
+ */
+import { peekConfig } from '@expofp/config';
+/**
+ * A value derived from the live event, built on first read and again on the
+ * first read after a new config is installed. Use it for state that has to be
+ * a single mutable object for the lifetime of one plan (the kind a plain
+ * function returning a fresh object each call cannot serve).
+ *
+ * @param build Produces the value for the event that is live when it runs.
+ * @returns A getter for the live event's value.
+ */
+export function eventScopedValue(build) {
+    let builtFor;
+    let built = false;
+    let value;
+    return () => {
+        const config = peekConfig();
+        if (!built || builtFor !== config) {
+            value = build();
+            builtFor = config;
+            built = true;
+        }
+        return value;
+    };
+}
+/** A `Map` that starts empty for every plan. */
+export function eventScopedCache() {
+    return eventScopedValue(() => new Map());
+}

package/dist/esm/tools/expofpUrl.d.ts

@@ -0,0 +1,7 @@
+export declare const EXPOFP_BASE_URL = "https://expofp.com/";
+export declare const UTM_CAMPAIGNS: {
+    readonly SUBDOMAIN_CTA: 'expofp_subdomain_cta';
+    readonly SUBDOMAIN_LOGO: 'expofp_subdomain_logo';
+};
+export declare function buildExpofpUrl(utmCampaign: string, path?: string): string;
+//# sourceMappingURL=expofpUrl.d.ts.map

package/dist/esm/tools/expofpUrl.js

@@ -0,0 +1,10 @@
+export const EXPOFP_BASE_URL = 'https://expofp.com/';
+export const UTM_CAMPAIGNS = {
+    SUBDOMAIN_CTA: 'expofp_subdomain_cta',
+    SUBDOMAIN_LOGO: 'expofp_subdomain_logo',
+};
+export function buildExpofpUrl(utmCampaign, path = '/') {
+    const url = new URL(path, EXPOFP_BASE_URL);
+    url.searchParams.set('utm_campaign', utmCampaign);
+    return url.toString();
+}

package/dist/esm/tools/freeBanner.d.ts

@@ -0,0 +1,5 @@
+export declare const FREE_BANNER_STORAGE_KEY = "free-dismissed5";
+export declare function readFreeBannerDismissed(storage: Storage): boolean;
+export declare function writeFreeBannerDismissed(storage: Storage): void;
+export declare function buildFreeBannerCtaUrl(): string;
+//# sourceMappingURL=freeBanner.d.ts.map

package/dist/esm/tools/freeBanner.js

@@ -0,0 +1,11 @@
+import { buildExpofpUrl, UTM_CAMPAIGNS } from './expofpUrl';
+export const FREE_BANNER_STORAGE_KEY = 'free-dismissed5';
+export function readFreeBannerDismissed(storage) {
+    return storage.getItem(FREE_BANNER_STORAGE_KEY) !== null;
+}
+export function writeFreeBannerDismissed(storage) {
+    storage.setItem(FREE_BANNER_STORAGE_KEY, '1');
+}
+export function buildFreeBannerCtaUrl() {
+    return buildExpofpUrl(UTM_CAMPAIGNS.SUBDOMAIN_CTA);
+}

package/dist/esm/tools/gtag.d.ts

@@ -0,0 +1,66 @@
+import { type Consent } from '@expofp/config';
+declare global {
+    interface Window {
+        dataLayer?: unknown[];
+        gtag?: typeof gtag;
+        [gaDisable: `ga-disable-${string}`]: boolean | undefined;
+    }
+}
+export default function gtag(...args: any[]): void;
+export declare enum GaEventActions {
+    Load = "Load floor plan",
+    ViewBooth = "View booth",
+    ViewExhibitor = "View exhibitor",
+    ViewCategory = "View category",
+    Search = "Search",
+    ClickCustomButton = "Click custom button",
+    ViewVideo = "View video",
+    ViewGallery = "View gallery",
+    ClickPhone = "Click phone",
+    ClickEmail = "Click email",
+    ClickWebsite = "Click website",
+    ClickFacebook = "Click Facebook",
+    ClickInstagaram = "Click Instagram",
+    ClickLinkedin = "Click Linkedin",
+    ClickTwitter = "Click Twitter",
+    ClickGooglePlus = "Click Google Plus",
+    ClickXing = "Click Xing",
+    ClickYoutube = "Click Youtube",
+    ClickBookmark = "Click bookmark",
+    ClickDirections = "Click Directions",
+    Rendered = "Floor plan rendered",
+    WsExhibitorClick = "ws_exhibitor_click"
+}
+export declare function checkUserIsGDPR(): Promise<boolean | null>;
+export declare function hasUserConsent(consent?: Consent): 'granted' | 'denied' | undefined;
+export declare function setCookieConsent(cookieConsent: boolean): void;
+export declare function setConsentSettings(consent?: Consent): void;
+export declare function sendEventToGa(action: GaEventActions, label: string, eventCategory?: string): void;
+/**
+ * Structured payloads for GA events that carry more than a single label,
+ * keyed by the GA action. Add an entry here to support a new structured
+ * event — `sendPayloadToGa` then type-checks the payload against the action.
+ */
+export interface GaEventPayloads {
+    [GaEventActions.WsExhibitorClick]: {
+        exhibitor_id: number;
+        exhibitor_name: string;
+        exhibitor_external_id: string;
+        creative_slot: 'ws_slider';
+    };
+}
+export declare function sendPayloadToGa<Action extends keyof GaEventPayloads>(action: Action, payload: GaEventPayloads[Action]): void;
+export declare function trackWsExhibitorClick(payload: {
+    id: number;
+    name: string;
+    externalId: string;
+}): void;
+/**
+ * Wires GA up for the plan being loaded: the event's own GA property and the
+ * `fp_key` every event is tagged with are the live event's, so this runs once
+ * per plan rather than once per page — module scope would leave the second
+ * event reporting into the first one's property (ADR-0011). The event's tag
+ * comes off again with the plan.
+ */
+export declare function initGtag(): void;
+//# sourceMappingURL=gtag.d.ts.map