@expofp/floorplan 0.0.0-experimental.2d6c681

package/dist/esm/utils/event-head.js

@@ -0,0 +1,90 @@
+/**
+ * The search-facing `<head>` (and the one `<h1>`) of an event page.
+ *
+ * The event shell served on `<expo>.expofp.com` is a bare HTML stub (aws-code
+ * `expo-index-v2`) with no description, heading or canonical, so crawlers that
+ * render JS get whatever the SDK writes. Every tag here fills a gap only — a
+ * page (or a future edge-generated shell) that already carries one wins — and
+ * the caller writes them only on our own event hosts (see is-own-domain.ts).
+ */
+/** Search engines cut meta descriptions off past roughly this length. */
+export const MAX_DESCRIPTION = 160;
+/** Cut to `max` characters on a word boundary, marking the cut with an ellipsis. */
+export function truncateAtWord(text, max) {
+    if (text.length <= max)
+        return text;
+    const cut = text.slice(0, max - 1);
+    const space = cut.lastIndexOf(' ');
+    return (space > 0 ? cut.slice(0, space) : cut).replace(/[\s,.:;–—|-]+$/u, '') + '…';
+}
+/** A BCP 47-looking tag (`en`, `pt-BR`, `zh-Hant`); anything else is not worth a `lang`. */
+const LANG_TAG = /^[a-z]{2,3}(?:-[a-z0-9]{2,8})*$/iu;
+export function buildEventHead(source) {
+    const title = source.title.trim();
+    const subtitle = source.subtitle.trim();
+    const lead = title ? `${title} interactive floor plan` : 'Interactive event floor plan';
+    const count = source.hideExhibitors ? 0 : source.exhibitors.length;
+    const offer = count > 0
+        ? `Browse ${count} exhibitors, find booths and get directions.`
+        : 'Find booths and get directions.';
+    const description = truncateAtWord(`${lead}${subtitle ? `: ${subtitle}` : ''}. ${offer}`, MAX_DESCRIPTION);
+    const locale = source.locale.trim();
+    return {
+        description,
+        heading: title || subtitle || undefined,
+        lang: LANG_TAG.test(locale) ? locale : undefined,
+    };
+}
+/**
+ * Visually hidden, still read by screen readers and crawlers: the map has no
+ * visible page heading to promote, and the event name is its honest one.
+ */
+const VISUALLY_HIDDEN = [
+    'position: absolute',
+    'width: 1px',
+    'height: 1px',
+    'margin: -1px',
+    'padding: 0',
+    'overflow: hidden',
+    'clip: rect(0, 0, 0, 0)',
+    'white-space: nowrap',
+    'border: 0',
+].join('; ');
+/** Write the event head into `doc`, filling only what the page lacks. */
+export function applyEventHead(doc, head, canonicalUrl) {
+    if (!doc.querySelector('meta[name="description"]')) {
+        const meta = doc.createElement('meta');
+        meta.name = 'description';
+        meta.content = head.description;
+        doc.head.appendChild(meta);
+    }
+    // The shell is one page whatever the query: `?ref=…`, `?kiosk=1` and the
+    // legacy deep links (`?<booth>`) are states of it, not separate documents.
+    if (!doc.querySelector('link[rel="canonical"]')) {
+        const link = doc.createElement('link');
+        link.rel = 'canonical';
+        link.href = canonicalUrl;
+        doc.head.appendChild(link);
+    }
+    if (head.heading && !doc.querySelector('h1')) {
+        const h1 = doc.createElement('h1');
+        h1.textContent = head.heading;
+        h1.style.cssText = VISUALLY_HIDDEN;
+        doc.body.prepend(h1);
+    }
+    if (head.lang)
+        doc.documentElement.lang = head.lang;
+}
+/**
+ * Keep a page out of the index — the "Event not found" screen: every unknown
+ * or removed event host answers 200 with the same shell (a soft 404 the edge
+ * cannot yet turn into a real one), so without this they index as duplicates.
+ */
+export function markNotIndexable(doc) {
+    if (doc.querySelector('meta[name="robots"]'))
+        return;
+    const meta = doc.createElement('meta');
+    meta.name = 'robots';
+    meta.content = 'noindex';
+    doc.head.appendChild(meta);
+}

package/dist/esm/utils/event-now.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Whether now falls within an event's dates. Date-only strings (`YYYY-MM-DD`)
+ * cover whole days. Read in the viewer's local time.
+ */
+export declare function isEventNow(startDate?: string, endDate?: string): boolean;
+/**
+ * Milliseconds until {@link isEventNow} flips for these dates, or `null` when it
+ * never will again (no dates, unparseable dates, or the event is over).
+ */
+export declare function msUntilEventNowChanges(startDate?: string, endDate?: string): number | null;
+//# sourceMappingURL=event-now.d.ts.map

package/dist/esm/utils/event-now.js

@@ -0,0 +1,40 @@
+const DATE_ONLY = /^\d{4}-\d{2}-\d{2}$/;
+/**
+ * A `YYYY-MM-DD` date at `time` of that day; any other string is parsed as is.
+ * Local time either way: event data carries no venue timezone.
+ */
+const parseEventDate = (date, time) => new Date(DATE_ONLY.test(date) ? `${date}T${time}` : date).getTime();
+const eventBounds = (startDate, endDate) => {
+    if (!startDate || !endDate)
+        return null;
+    return {
+        start: parseEventDate(startDate, '00:00:00'),
+        end: parseEventDate(endDate, '23:59:59'),
+    };
+};
+/**
+ * Whether now falls within an event's dates. Date-only strings (`YYYY-MM-DD`)
+ * cover whole days. Read in the viewer's local time.
+ */
+export function isEventNow(startDate, endDate) {
+    const bounds = eventBounds(startDate, endDate);
+    if (!bounds)
+        return false;
+    const now = Date.now();
+    return now >= bounds.start && now <= bounds.end;
+}
+/**
+ * Milliseconds until {@link isEventNow} flips for these dates, or `null` when it
+ * never will again (no dates, unparseable dates, or the event is over).
+ */
+export function msUntilEventNowChanges(startDate, endDate) {
+    const bounds = eventBounds(startDate, endDate);
+    if (!bounds)
+        return null;
+    const now = Date.now();
+    if (now < bounds.start)
+        return bounds.start - now;
+    if (now <= bounds.end)
+        return bounds.end - now + 1;
+    return null;
+}

package/dist/esm/utils/event-title.d.ts

@@ -0,0 +1,19 @@
+import type { Brand } from './brand';
+interface EventTitleSource {
+    title: string;
+    subtitle: string;
+}
+/**
+ * The final, real title — event name (+ subtitle), known once `data.js` is
+ * loaded. Undefined when the event has neither (both default to `''`): the
+ * bare brand suffix would be the same for every such event, so the caller
+ * keeps the hostname-derived placeholder instead.
+ */
+export declare function formatEventTitle(source: EventTitleSource, brand: Brand): string | undefined;
+/**
+ * Synchronous placeholder set before any network request completes.
+ * Hostname-derived, not a literal constant, so it's unique per event.
+ */
+export declare function formatPlaceholderTitle(hostname: string, brand: Brand): string;
+export {};
+//# sourceMappingURL=event-title.d.ts.map

package/dist/esm/utils/event-title.js

@@ -0,0 +1,20 @@
+/**
+ * The final, real title — event name (+ subtitle), known once `data.js` is
+ * loaded. Undefined when the event has neither (both default to `''`): the
+ * bare brand suffix would be the same for every such event, so the caller
+ * keeps the hostname-derived placeholder instead.
+ */
+export function formatEventTitle(source, brand) {
+    const parts = [source.title, source.subtitle].filter(Boolean);
+    if (!parts.length)
+        return undefined;
+    return [...parts, `Expo Floor Plan by ${brand}`].join(' – ');
+}
+/**
+ * Synchronous placeholder set before any network request completes.
+ * Hostname-derived, not a literal constant, so it's unique per event.
+ */
+export function formatPlaceholderTitle(hostname, brand) {
+    const [slug] = hostname.split('.');
+    return `${slug || hostname} – Expo Floor Plan by ${brand}`;
+}

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

@@ -0,0 +1,3 @@
+import { type EventItem } from '../store/EventStore';
+export declare function shouldShowEventFullBadge(event: EventItem): boolean;
+//# sourceMappingURL=eventFullBadge.d.ts.map

package/dist/esm/utils/eventFullBadge.js

@@ -0,0 +1,7 @@
+import settings from '../tools/settings';
+const FULL_EVENT_IDS = [9148, 9151];
+export function shouldShowEventFullBadge(event) {
+    const isDemoMap = settings.EXPO === 'demo';
+    const isFullEvent = FULL_EVENT_IDS.includes(event.id) || FULL_EVENT_IDS.includes(event.externalId);
+    return isDemoMap && isFullEvent;
+}

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

@@ -0,0 +1,15 @@
+export type EventStatus = 'live' | 'upcoming' | 'starting-soon' | 'past' | 'none';
+interface TimeUntilStartData {
+    minutes: number;
+    seconds: number;
+    totalSeconds: number;
+    isLessThan10Minutes: boolean;
+}
+export declare function calculateTimeUntilStart(startDate: string, now: number): TimeUntilStartData;
+export declare function getEventStatus(event: {
+    startDate: string;
+    endDate?: string;
+}, now: number, timeUntil: TimeUntilStartData): EventStatus;
+export declare function getEventStatusLabel(status: EventStatus, timeUntil: TimeUntilStartData): string;
+export {};
+//# sourceMappingURL=eventTime.d.ts.map

package/dist/esm/utils/eventTime.js

@@ -0,0 +1,82 @@
+import { t } from './i18n';
+function parseDateSafe(dateStr) {
+    if (!dateStr)
+        return null;
+    const ts = Date.parse(dateStr);
+    return isNaN(ts) ? null : ts;
+}
+export function calculateTimeUntilStart(startDate, now) {
+    const start = parseDateSafe(startDate);
+    if (start === null) {
+        return {
+            minutes: 0,
+            seconds: 0,
+            totalSeconds: 0,
+            isLessThan10Minutes: false,
+        };
+    }
+    const diffMs = start - now;
+    if (diffMs <= 0) {
+        return {
+            minutes: 0,
+            seconds: 0,
+            totalSeconds: 0,
+            isLessThan10Minutes: false,
+        };
+    }
+    const totalSeconds = Math.floor(diffMs / 1000);
+    const minutes = Math.floor(totalSeconds / 60);
+    const seconds = totalSeconds % 60;
+    return {
+        minutes,
+        seconds,
+        totalSeconds,
+        isLessThan10Minutes: totalSeconds < 600,
+    };
+}
+export function getEventStatus(event, now, timeUntil) {
+    const start = parseDateSafe(event.startDate);
+    const end = parseDateSafe(event.endDate) ?? Number.POSITIVE_INFINITY;
+    if (start === null || end === null)
+        return 'none';
+    if (now > end)
+        return 'past';
+    if (start - now <= 1000 && now <= end)
+        return 'live';
+    if (now >= start && now <= end)
+        return 'live';
+    if (timeUntil.totalSeconds > 0 && timeUntil.totalSeconds <= 3600)
+        return 'starting-soon';
+    const sixHoursFromNow = now + 6 * 60 * 60 * 1000;
+    if (start <= sixHoursFromNow)
+        return 'upcoming';
+    return 'none';
+}
+function formatTimeUntilStart(timeUntil) {
+    if (timeUntil.isLessThan10Minutes) {
+        const mm = String(timeUntil.minutes).padStart(2, '0');
+        const ss = String(timeUntil.seconds).padStart(2, '0');
+        return `${mm}:${ss}`;
+    }
+    return `${timeUntil.minutes}`;
+}
+export function getEventStatusLabel(status, timeUntil) {
+    switch (status) {
+        case 'live':
+            return t('LIVE');
+        case 'upcoming':
+            return t('UPCOMING');
+        case 'starting-soon': {
+            if (timeUntil.totalSeconds <= 0)
+                return t('Started');
+            if (timeUntil.isLessThan10Minutes) {
+                return t('Starts in {{time}}', { time: formatTimeUntilStart(timeUntil) });
+            }
+            return t('Starts in {{count}} min', { count: timeUntil.minutes });
+        }
+        case 'past':
+            return t('PAST');
+        default:
+            return '';
+    }
+}

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

@@ -0,0 +1,5 @@
+export declare function extractMetaFromString(input: string): {
+    text: string;
+    meta: Record<string, string>;
+};
+//# sourceMappingURL=extractMetaFromString.d.ts.map

package/dist/esm/utils/extractMetaFromString.js

@@ -0,0 +1,16 @@
+import { STRING_META_DELIMITER } from '../constants';
+export function extractMetaFromString(input) {
+    const parts = input.split(STRING_META_DELIMITER);
+    if (parts.length !== 2) {
+        return { text: input, meta: {} };
+    }
+    const [text, metaPart] = parts;
+    const meta = metaPart.split(',').reduce((acc, pair) => {
+        const [key, value] = pair.split(':');
+        if (key) {
+            acc[key.trim()] = value?.trim() ?? '';
+        }
+        return acc;
+    }, {});
+    return { text, meta };
+}

package/dist/esm/utils/geo-anchors.d.ts

@@ -0,0 +1,10 @@
+import type { GeoAnchor } from '@expofp/geometry';
+import type { GpsConfig } from './gps.js';
+/**
+ * Builds the two-anchor affine bridge (p0 → anchor a, p2 → anchor b) that every
+ * plan ⇄ GPS projection in the SDK shares. Kept in its own leaf module so pure
+ * projection code can reuse the convention without pulling in `gps.ts`'s
+ * `window`-dependent plan globals.
+ */
+export declare function geoAnchors(config: GpsConfig): [GeoAnchor, GeoAnchor];
+//# sourceMappingURL=geo-anchors.d.ts.map

package/dist/esm/utils/geo-anchors.js

@@ -0,0 +1,12 @@
+/**
+ * Builds the two-anchor affine bridge (p0 → anchor a, p2 → anchor b) that every
+ * plan ⇄ GPS projection in the SDK shares. Kept in its own leaf module so pure
+ * projection code can reuse the convention without pulling in `gps.ts`'s
+ * `window`-dependent plan globals.
+ */
+export function geoAnchors(config) {
+    return [
+        { local: { x: config.p0.x, y: config.p0.y }, geo: { lat: config.p0.lat, lng: config.p0.lng } },
+        { local: { x: config.p2.x, y: config.p2.y }, geo: { lat: config.p2.lat, lng: config.p2.lng } },
+    ];
+}

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

@@ -0,0 +1,2 @@
+export declare function pointInTriangle(x: number, y: number, triangle: number[][]): boolean;
+//# sourceMappingURL=geometry.d.ts.map

package/dist/esm/utils/geometry.js

@@ -0,0 +1,12 @@
+export function pointInTriangle(x, y, triangle) {
+    const [x1, y1] = triangle[0];
+    const [x2, y2] = triangle[1];
+    const [x3, y3] = triangle[2];
+    const denominator = (y2 - y3) * (x1 - x3) + (x3 - x2) * (y1 - y3);
+    if (denominator === 0)
+        return false;
+    const a = ((y2 - y3) * (x - x3) + (x3 - x2) * (y - y3)) / denominator;
+    const b = ((y3 - y1) * (x - x3) + (x1 - x3) * (y - y3)) / denominator;
+    const c = 1 - a - b;
+    return a >= 0 && a <= 1 && b >= 0 && b <= 1 && c >= 0 && c <= 1;
+}

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

@@ -0,0 +1,2 @@
+export declare function getContrastTextColor(hexColor: string): string;
+//# sourceMappingURL=getContrastTextColor.d.ts.map

package/dist/esm/utils/getContrastTextColor.js

@@ -0,0 +1,26 @@
+const LUMINANCE_THRESHOLD = 150;
+const DARK_TEXT = '#1a1a1a';
+const LIGHT_TEXT = '#ffffff';
+const HEX_PATTERN = /^[0-9A-Fa-f]{6}$/;
+const SHORT_HEX_PATTERN = /^[0-9A-Fa-f]{3}$/;
+function normalizeHex(hexColor) {
+    const hex = hexColor.replace('#', '');
+    if (HEX_PATTERN.test(hex)) {
+        return hex;
+    }
+    if (SHORT_HEX_PATTERN.test(hex)) {
+        return hex[0] + hex[0] + hex[1] + hex[1] + hex[2] + hex[2];
+    }
+    return null;
+}
+export function getContrastTextColor(hexColor) {
+    const hex = normalizeHex(hexColor);
+    if (!hex) {
+        return DARK_TEXT;
+    }
+    const r = parseInt(hex.substring(0, 2), 16);
+    const g = parseInt(hex.substring(2, 4), 16);
+    const b = parseInt(hex.substring(4, 6), 16);
+    const luminance = 0.299 * r + 0.587 * g + 0.114 * b;
+    return luminance > LUMINANCE_THRESHOLD ? DARK_TEXT : LIGHT_TEXT;
+}

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

@@ -0,0 +1,9 @@
+import { type Logo } from '@expofp/schema';
+/**
+ * The logo URL to load for the current device: the pre-scaled `small`/`tiny`
+ * variant on optimized mobile/webview sessions, the full logo otherwise.
+ * Variant URLs are explicit fields on the logo (the config derives them when
+ * the platform serves the legacy string form) — nothing is re-derived here.
+ */
+export declare function getLogoUrl(logo: Logo): string;
+//# sourceMappingURL=getLogoUrl.d.ts.map

package/dist/esm/utils/getLogoUrl.js

@@ -0,0 +1,26 @@
+import data from '../data';
+import isMobile from './is-mobile';
+import isWebview from './is-webview';
+/**
+ * The logo URL to load for the current device: the pre-scaled `small`/`tiny`
+ * variant on optimized mobile/webview sessions, the full logo otherwise.
+ * Variant URLs are explicit fields on the logo (the config derives them when
+ * the platform serves the legacy string form) — nothing is re-derived here.
+ */
+export function getLogoUrl(logo) {
+    const suffix = getSmallLogoUrlSuffix();
+    if (suffix === 'tiny')
+        return logo.tinyUrl ?? logo.smallUrl ?? logo.url;
+    if (suffix === 'small')
+        return logo.smallUrl ?? logo.url;
+    return logo.url;
+}
+function getSmallLogoUrlSuffix() {
+    if (isMobile || isWebview) {
+        // EFP-4851: If viewOptimizationLevel = 0 then return logos with original quality
+        if (!data.viewOptimizationLevel)
+            return;
+        return data.viewOptimizationLevel >= 5 ? 'tiny' : 'small';
+    }
+    return;
+}

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

@@ -0,0 +1,2 @@
+export declare function getMostFrequent(arr: string[]): undefined;
+//# sourceMappingURL=getMostFrequent.d.ts.map

package/dist/esm/utils/getMostFrequent.js

@@ -0,0 +1,14 @@
+// @ts-nocheck
+export function getMostFrequent(arr) {
+    const frequency = {};
+    let maxCount = 0;
+    let mostFrequent;
+    arr.forEach((item) => {
+        frequency[item] = (frequency[item] || 0) + 1;
+        if (frequency[item] > maxCount) {
+            maxCount = frequency[item];
+            mostFrequent = item;
+        }
+    });
+    return mostFrequent;
+}

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

@@ -0,0 +1,2 @@
+export declare function getRenderTargetFromRoot(rootElement: HTMLElement | null): HTMLElement | null;
+//# sourceMappingURL=getRenderTargetFromRoot.d.ts.map

package/dist/esm/utils/getRenderTargetFromRoot.js

@@ -0,0 +1,19 @@
+export function getRenderTargetFromRoot(rootElement) {
+    if (!rootElement) {
+        console.error('[getRenderTargetFromRoot] rootElement is null');
+        return null;
+    }
+    const firstChild = rootElement.firstElementChild;
+    if (firstChild && firstChild.shadowRoot) {
+        const layout = firstChild.shadowRoot.querySelector('#efp-layout');
+        if (layout) {
+            return layout;
+        }
+    }
+    const layout = rootElement.querySelector?.('#efp-layout');
+    if (layout) {
+        return layout;
+    }
+    console.error('[getRenderTargetFromRoot] rootElement is null');
+    return null;
+}

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

@@ -0,0 +1,40 @@
+import { type CurrentPosition } from '../store/RouteStore';
+export interface GpsConfig {
+    p0: {
+        x: number;
+        y: number;
+        lat: number;
+        lng: number;
+    };
+    p1?: {
+        x: number;
+        y: number;
+        lat: number;
+        lng: number;
+    };
+    p2: {
+        x: number;
+        y: number;
+        lat: number;
+        lng: number;
+    };
+}
+export interface PointWithAngle {
+    x: number;
+    y: number;
+    angle?: number;
+}
+/**
+ * What these projections actually read off a position: only the geographic
+ * fields, so callers holding just a lat/lng pair do not have to fabricate a
+ * `CurrentPosition` with meaningless x/y.
+ */
+type GpsPosition = Pick<CurrentPosition, 'lat' | 'lng' | 'angle'>;
+export declare function isValidPointCoords(value: unknown): value is number;
+/** Projects a trusted map-camera point without the user-location distance guard. */
+export declare function projectMapPointToLocal({ lat, lng, angle }: GpsPosition, config: GpsConfig): PointWithAngle | null;
+export declare function convertGpsToLocal({ lat, lng, angle }: GpsPosition, config: GpsConfig): PointWithAngle | null;
+export declare function convertLocalToGps(x: number, y: number, geoConfig: GpsConfig): [number, number];
+export declare function calculateRelativeBearing(point: PointWithAngle): number;
+export {};
+//# sourceMappingURL=gps.d.ts.map

package/dist/esm/utils/gps.js

@@ -0,0 +1,66 @@
+/* eslint-disable prefer-const */
+// @ts-nocheck
+import { haversineDistance, lineCenter, lineLength, pointDistance, projectGpsToLocal, projectLocalToGps, } from '@expofp/geometry';
+import { getFpGeo } from '../data/fpGeo.js';
+import logger from '../tools/logger';
+// The two-anchor affine bridge shared by convertLocalToGps / convertGpsToLocal.
+// All GeoConfig parsing/validation stays here; only the pure projection math
+// lives in @expofp/geometry's geo module.
+import { geoAnchors } from './geo-anchors';
+import { planBearing } from './planBearing';
+export function isValidPointCoords(value) {
+    return typeof value === 'number' && Number.isFinite(value);
+}
+/** Projects a trusted map-camera point without the user-location distance guard. */
+export function projectMapPointToLocal({ lat, lng, angle }, config) {
+    if (!(isValidPointCoords(lat) && isValidPointCoords(lng)))
+        return null;
+    const [a, b] = geoAnchors(config);
+    const locationPixel = projectGpsToLocal({ lat, lng }, a, b);
+    if (!(isValidPointCoords(locationPixel.x) && isValidPointCoords(locationPixel.y)))
+        return null;
+    return { ...locationPixel, angle };
+}
+export function convertGpsToLocal({ lat, lng, angle }, config) {
+    if (!(isValidPointCoords(lat) && isValidPointCoords(lng)))
+        return null;
+    let { p0, p2 } = config;
+    const fullGpsDistance = haversineDistance(p0, p2);
+    if (!isValidPointCoords(fullGpsDistance) || fullGpsDistance <= 0) {
+        logger.warn('Invalid GPS config: zero or negative distance', {
+            fullGpsDistance,
+            p0,
+            p2,
+        });
+        return null;
+    }
+    // Current point position in SVG coordinates (the two-anchor affine inverse).
+    let locationPixel = projectMapPointToLocal({ lat, lng, angle }, config);
+    if (!locationPixel)
+        return null;
+    let distToCenter = lineLength({ p0: locationPixel, p1: lineCenter({ p0, p1: p2 }) });
+    let diagonale = pointDistance(p0, p2);
+    if (distToCenter > 5 * diagonale) {
+        logger.warn('Current position too far');
+        return null;
+    }
+    return locationPixel;
+}
+export function convertLocalToGps(x, y, geoConfig) {
+    const [a, b] = geoAnchors(geoConfig);
+    const { lat, lng } = projectLocalToGps({ x, y }, a, b);
+    return [lng, lat];
+}
+export function calculateRelativeBearing(point) {
+    const config = getFpGeo()?.properties?.config;
+    // Plan rotation from the p0->p2 diagonal, matching the map camera bearing.
+    // Falls back to the stored bearing for invalid/missing anchors.
+    const derived = config ? planBearing(config.p0, config.p2) : NaN;
+    const bearing = Number.isFinite(derived) ? derived : (config?.bearing ?? 0);
+    if (point?.angle === null)
+        return 0;
+    const planRelative = (((point.angle - bearing) % 360) + 360) % 360;
+    // north → screen
+    const screenAngle = planRelative - 90;
+    return (screenAngle + 360) % 360;
+}

package/dist/esm/utils/heatmap-enabled.d.ts

@@ -0,0 +1,13 @@
+import { type Heatmap } from '@expofp/schema';
+/**
+ * Does a `config.heatmap` node engage heatmap mode? Presence implies intent:
+ * any non-empty node engages unless switched off with an explicit
+ * `enabled: false` — so `?heatmap[variant]=yah` alone is enough, and a URL's
+ * `?heatmap[enabled]=false` can veto a manifest-set node (config layers
+ * replace the node wholesale). One predicate for both consumers — the data
+ * loader's fetch decision and the dispatch's mode engagement — so the rule
+ * cannot drift. The legacy `?heatmap=true` params are NOT this node: they stay
+ * a legacy-URL one-shot and a raw read in the loader.
+ */
+export declare function heatmapEnabled(heatmap: Heatmap): boolean;
+//# sourceMappingURL=heatmap-enabled.d.ts.map

package/dist/esm/utils/heatmap-enabled.js

@@ -0,0 +1,13 @@
+/**
+ * Does a `config.heatmap` node engage heatmap mode? Presence implies intent:
+ * any non-empty node engages unless switched off with an explicit
+ * `enabled: false` — so `?heatmap[variant]=yah` alone is enough, and a URL's
+ * `?heatmap[enabled]=false` can veto a manifest-set node (config layers
+ * replace the node wholesale). One predicate for both consumers — the data
+ * loader's fetch decision and the dispatch's mode engagement — so the rule
+ * cannot drift. The legacy `?heatmap=true` params are NOT this node: they stay
+ * a legacy-URL one-shot and a raw read in the loader.
+ */
+export function heatmapEnabled(heatmap) {
+    return Object.keys(heatmap).length > 0 && heatmap.enabled !== false;
+}

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

@@ -0,0 +1,18 @@
+import { TFunction } from 'i18next';
+export declare const getLocale: () => string;
+export declare const getLocales: () => readonly Language[];
+export declare const hasLocale: (id: string | undefined) => id is string;
+export declare const t: (template: string, options?: any) => string;
+/**
+ * Like {@link t}, but only looks the string up when a matching key exists in the
+ * active locale; otherwise it returns the string verbatim. Use for values that
+ * may be organizer-authored (e.g. search-button names): built-in labels still
+ * localize and react to language switches, while custom names pass through
+ * without tripping saveMissing / missingKeyHandler (console noise + extra work)
+ * in non-English locales.
+ */
+export declare const tIfExists: (template: string, options?: any) => string;
+export declare const initI18n: () => Promise<TFunction>;
+export declare const setLocale: (id: string) => Promise<void>;
+export declare const resetLocale: () => Promise<void>;
+//# sourceMappingURL=i18n.d.ts.map