@expofp/floorplan 0.0.0-experimental.cf063fc

package/dist/esm/utils/blob-image-size.js

@@ -0,0 +1,37 @@
+/**
+ * Measures an image's intrinsic size without keeping its pixels.
+ *
+ * Floorplan needs one number from a logo's pixels: the aspect ratio, to fit the logo inside a
+ * booth. `createImageBitmap` gives that number at low cost. The browser decodes the image on its
+ * own thread. Then it resolves a promise. The main thread pays only for the call and for the
+ * promise resolution, not for the decode itself. This is the difference between
+ * `createImageBitmap` and an `<img>` element, which decodes on the same thread as the page.
+ *
+ * The function closes the bitmap right after it reads the size. A caller can start as many calls
+ * as it wants. At any instant, only a few bitmaps exist in memory: the ones the browser's decoder
+ * already finished but did not yet hand back. The whole batch of logos never sits in memory
+ * together. One cost remains, and this cost is accepted: each logo gets decoded twice, once here
+ * and once in the atlas worker. This happens because a Blob cannot report its own size, and the
+ * renderer does not report one back either.
+ *
+ * This function has no `<img>` fallback. `createImageBitmap` works on every build target that
+ * this SDK supports. The only targets that lack `createImageBitmap` are targets where the whole
+ * SDK already fails to run.
+ * @param blob - The image bytes.
+ * @returns The size, or `null` if the bytes cannot be decoded.
+ */
+export async function blobImageSize(blob) {
+    try {
+        const bitmap = await createImageBitmap(blob);
+        const size = { width: bitmap.width, height: bitmap.height };
+        // The code closes the bitmap now, not after the function returns. The bitmap exists only
+        // long enough to read its width and height. Garbage collection does not reclaim pixel memory
+        // outside the JavaScript heap right away.
+        bitmap.close();
+        return size;
+    }
+    catch {
+        // These bytes did not decode. The caller drops the logo instead of guessing its ratio.
+        return null;
+    }
+}

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

@@ -0,0 +1,18 @@
+export type Brand = 'ExpoFP' | 'LocoMaven';
+/**
+ * Apex domain → brand: every event is `<expo>.<apex>` (aws-code README), and
+ * the domain is what decides the brand. Not taken from the manifest's
+ * `locomaven` flag (aws-code `manifest-json`) — the lambda derives that from
+ * the same domain, and the placeholder title is written before any request
+ * settles, so only the hostname is known at both moments.
+ */
+declare const BRAND_BY_APEX: {
+    readonly 'expofp.com': 'ExpoFP';
+    readonly 'locomaven.com': 'LocoMaven';
+};
+export declare const OWN_APEX_DOMAINS: (keyof typeof BRAND_BY_APEX)[];
+/** Pure so it's testable without stubbing `window.location`. */
+export declare function computeBrand(hostname: string): Brand;
+export declare const brand: Brand;
+export {};
+//# sourceMappingURL=brand.d.ts.map

package/dist/esm/utils/brand.js

@@ -0,0 +1,19 @@
+/**
+ * Apex domain → brand: every event is `<expo>.<apex>` (aws-code README), and
+ * the domain is what decides the brand. Not taken from the manifest's
+ * `locomaven` flag (aws-code `manifest-json`) — the lambda derives that from
+ * the same domain, and the placeholder title is written before any request
+ * settles, so only the hostname is known at both moments.
+ */
+const BRAND_BY_APEX = {
+    'expofp.com': 'ExpoFP',
+    'locomaven.com': 'LocoMaven',
+};
+export const OWN_APEX_DOMAINS = Object.keys(BRAND_BY_APEX);
+const DEFAULT_BRAND = 'ExpoFP';
+/** Pure so it's testable without stubbing `window.location`. */
+export function computeBrand(hostname) {
+    const apex = OWN_APEX_DOMAINS.find((d) => hostname === d || hostname.endsWith(`.${d}`));
+    return apex ? BRAND_BY_APEX[apex] : DEFAULT_BRAND;
+}
+export const brand = typeof window === 'undefined' ? DEFAULT_BRAND : computeBrand(window.location.hostname);

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

@@ -0,0 +1,4 @@
+import Bowser from 'bowser';
+declare const browser: Bowser.Parser.Parser;
+export default browser;
+//# sourceMappingURL=browser.d.ts.map

package/dist/esm/utils/browser.js

@@ -0,0 +1,4 @@
+import Bowser from 'bowser';
+const ua = window.navigator.userAgent;
+const browser = Bowser.getParser(ua);
+export default browser;

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

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

package/dist/esm/utils/calcSpeed.js

@@ -0,0 +1,5 @@
+const METERS_PER_SECOND = 1.4;
+const FEET_PER_SECOND = 4.2;
+export function calcSpeed(units) {
+    return units?.toLowerCase?.().trim() === 'm' ? METERS_PER_SECOND : FEET_PER_SECOND;
+}

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

@@ -0,0 +1,2 @@
+export declare function calcTravelTime(distance: number, speed: number): number;
+//# sourceMappingURL=calcTravelTime.d.ts.map

package/dist/esm/utils/calcTravelTime.js

@@ -0,0 +1,3 @@
+export function calcTravelTime(distance, speed) {
+    return Math.round(distance / speed);
+}

package/dist/esm/utils/camera-map-settings.d.ts

@@ -0,0 +1,26 @@
+import { type Camera } from '@expofp/schema';
+import { type MapSettings } from '../store/types';
+/**
+ * Translates the public {@link Camera} shape into the internal
+ * {@link MapSettings} one (the `uiState.mapSettings` observable that the map
+ * reaction applies once the renderer is ready). Only the fields present in
+ * `camera` appear in the result, so a partial camera stays a partial settings
+ * patch. `x`/`y` and `lat`/`lng` are pairs — a half-given pair is dropped, as
+ * the serialized center would be meaningless.
+ */
+export declare function cameraToMapSettings(camera: Camera): MapSettings;
+/**
+ * The reverse of {@link cameraToMapSettings}: reads the internal
+ * {@link MapSettings} back into the public {@link Camera} shape. A serialized
+ * center whose halves don't parse as finite numbers (legacy URLs can carry
+ * arbitrary strings) is skipped rather than surfaced
+ * as `NaN`.
+ */
+export declare function mapSettingsToCamera(settings: MapSettings): Camera;
+/**
+ * Parses a serialized `"a,b"` pair, rejecting anything that is not exactly two
+ * finite numbers — legacy URLs and kiosk records can carry arbitrary strings,
+ * and a half-parsed pair would reach the camera as `NaN`.
+ */
+export declare function parseNumberPair(value: string | undefined): [number, number] | undefined;
+//# sourceMappingURL=camera-map-settings.d.ts.map

package/dist/esm/utils/camera-map-settings.js

@@ -0,0 +1,86 @@
+/**
+ * Translates the public {@link Camera} shape into the internal
+ * {@link MapSettings} one (the `uiState.mapSettings` observable that the map
+ * reaction applies once the renderer is ready). Only the fields present in
+ * `camera` appear in the result, so a partial camera stays a partial settings
+ * patch. `x`/`y` and `lat`/`lng` are pairs — a half-given pair is dropped, as
+ * the serialized center would be meaningless.
+ */
+export function cameraToMapSettings(camera) {
+    const settings = {};
+    if (camera.x !== undefined && camera.y !== undefined) {
+        settings.centerxy = `${camera.x},${camera.y}`;
+    }
+    if (camera.lat !== undefined && camera.lng !== undefined) {
+        settings.center = `${camera.lat},${camera.lng}`;
+    }
+    if (camera.floor !== undefined) {
+        settings.z = camera.floor;
+    }
+    if (camera.venue !== undefined) {
+        settings.venue = camera.venue;
+    }
+    if (camera.bearing !== undefined) {
+        settings.bearing = camera.bearing;
+    }
+    if (camera.zoomTime !== undefined) {
+        settings.zoomtime = camera.zoomTime;
+    }
+    if (camera.pitchTime !== undefined) {
+        settings.pitchtime = camera.pitchTime;
+    }
+    if (camera.pitchDegrees !== undefined) {
+        settings.pitchdegrees = camera.pitchDegrees;
+    }
+    return settings;
+}
+/**
+ * The reverse of {@link cameraToMapSettings}: reads the internal
+ * {@link MapSettings} back into the public {@link Camera} shape. A serialized
+ * center whose halves don't parse as finite numbers (legacy URLs can carry
+ * arbitrary strings) is skipped rather than surfaced
+ * as `NaN`.
+ */
+export function mapSettingsToCamera(settings) {
+    const camera = {};
+    const centerxy = parseNumberPair(settings.centerxy);
+    if (centerxy) {
+        [camera.x, camera.y] = centerxy;
+    }
+    const center = parseNumberPair(settings.center);
+    if (center) {
+        [camera.lat, camera.lng] = center;
+    }
+    if (settings.z !== undefined) {
+        camera.floor = settings.z;
+    }
+    if (settings.venue !== undefined) {
+        camera.venue = settings.venue;
+    }
+    if (settings.bearing !== undefined) {
+        camera.bearing = settings.bearing;
+    }
+    if (settings.zoomtime !== undefined) {
+        camera.zoomTime = settings.zoomtime;
+    }
+    if (settings.pitchtime !== undefined) {
+        camera.pitchTime = settings.pitchtime;
+    }
+    if (settings.pitchdegrees !== undefined) {
+        camera.pitchDegrees = settings.pitchdegrees;
+    }
+    return camera;
+}
+/**
+ * Parses a serialized `"a,b"` pair, rejecting anything that is not exactly two
+ * finite numbers — legacy URLs and kiosk records can carry arbitrary strings,
+ * and a half-parsed pair would reach the camera as `NaN`.
+ */
+export function parseNumberPair(value) {
+    if (!value)
+        return undefined;
+    const parts = value.split(',').map(Number);
+    if (parts.length !== 2 || !parts.every(Number.isFinite))
+        return undefined;
+    return [parts[0], parts[1]];
+}

package/dist/esm/utils/color-gradient.d.ts

@@ -0,0 +1,2 @@
+export declare function getColorFromGradient(clickCount: number, min: number, max: number, palette: string[]): string;
+//# sourceMappingURL=color-gradient.d.ts.map

package/dist/esm/utils/color-gradient.js

@@ -0,0 +1,14 @@
+import Color from 'color';
+export function getColorFromGradient(clickCount, min, max, palette) {
+    if (palette.length === 0)
+        return 'transparent';
+    const colorPalette = palette.map((color) => Color(color));
+    const normalizedValue = Math.max(0, Math.min((clickCount - min) / (max - min) || 0, 1));
+    // sqrt scaling gives more color resolution at the low end of the range
+    const scaled = Math.sqrt(normalizedValue) * (colorPalette.length - 1);
+    const colorIndex = Math.min(Math.floor(scaled), colorPalette.length - 1);
+    const colorStart = colorPalette[colorIndex];
+    const colorEnd = colorPalette[Math.min(colorIndex + 1, colorPalette.length - 1)];
+    const interpolationFactor = scaled - colorIndex;
+    return colorStart.mix(colorEnd, interpolationFactor).hex();
+}

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

@@ -0,0 +1,2 @@
+export declare function handleCustomCommand(text: string): boolean;
+//# sourceMappingURL=customCommands.d.ts.map

package/dist/esm/utils/customCommands.js

@@ -0,0 +1,33 @@
+import { DEBUG_KEY, SET_KIOSK_KEY } from '../constants';
+import data from '../data';
+import store, { uiState } from '../store';
+import { handleDebugMode } from '../tools/handleDebugMode';
+import { getRebookingTokenFromQuery } from '../tools/rebookingUrl';
+export function handleCustomCommand(text) {
+    text = text.trim();
+    if (text.toLowerCase() === '__addcache') {
+        navigator.serviceWorker.getRegistrations().then((registrations) => {
+            if (!registrations.length)
+                return alert('No registered service workers.');
+            const images = [];
+            store.exhibitorStore.exhibitors.forEach((exhibitor) => {
+                if (exhibitor.logo?.url)
+                    images.push(exhibitor.logo.url);
+                images.push(...(exhibitor.gallery || []));
+            });
+            Promise.all(images.map((image) => fetch(image)))
+                .then((value) => alert(`${value.length} images loaded.`))
+                .catch((error) => alert(error));
+        });
+    }
+    else if (getRebookingTokenFromQuery()) {
+        return true;
+    }
+    else if (text.startsWith(DEBUG_KEY)) {
+        handleDebugMode();
+    }
+    else if (text === (data.customSetKiosk || SET_KIOSK_KEY)) {
+        uiState.enableSetKioskMode(true);
+    }
+    return false;
+}

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

@@ -0,0 +1,2 @@
+export declare function detectLimitedModeViaImage(src?: string): Promise<boolean>;
+//# sourceMappingURL=detectLimitedModeViaImage.d.ts.map

package/dist/esm/utils/detectLimitedModeViaImage.js

@@ -0,0 +1,33 @@
+import baseRuntimeUrl from '../tools/base-runtime-url';
+import { loadImage } from './loadImage';
+const DEFAULT_IMAGE_SRC = `${baseRuntimeUrl}expofp-overlay.png`;
+export async function detectLimitedModeViaImage(src = DEFAULT_IMAGE_SRC) {
+    try {
+        const img = await loadImage(src);
+        const c = document.createElement('canvas');
+        c.width = 1;
+        c.height = 1;
+        const ctx = c.getContext('2d');
+        // If a 2D context cannot be obtained, treat this as limited mode.
+        if (!ctx) {
+            return true;
+        }
+        try {
+            ctx.drawImage(img, 0, 0, 1, 1);
+            // If the canvas is tainted (common under file://), this throws.
+            ctx.getImageData(0, 0, 1, 1);
+            // No throw => not in limited/tainted mode.
+            return false;
+        }
+        catch (err) {
+            // Any error during canvas access — treat as limited/tainted mode to be safe.
+            return true;
+        }
+    }
+    catch (err) {
+        // If the image itself can’t load, treat file:// as limited/tainted, but
+        // avoid flagging limited mode for generic network/CDN failures under HTTP(S).
+        const isFileProtocol = typeof location !== 'undefined' && location.protocol === 'file:';
+        return isFileProtocol;
+    }
+}

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

@@ -0,0 +1,27 @@
+import { type SceneDef } from '@expofp/renderer';
+export declare const DIM_INTENSITY = 0.5;
+export declare const VENUE_DIM_INTENSITY = 1;
+export declare const DIM_TRANSITION_MS = 300;
+export declare const DEFAULT_DIM_EASING: 'cubic';
+export type DimmingEasing = 'linear' | 'cubic';
+export interface DimmingAnimator {
+    getValue(): number;
+    setTarget(dimmed: boolean, options?: {
+        immediate?: boolean;
+    }): void;
+    stop(): void;
+}
+/**
+ * Writes a venue-wide dim onto a scene's root layer, from which it descends to every layer and def
+ * that does not set a `dim` of its own.
+ *
+ * Only the write — the caller commits it through `update`, which is what lets an eased dim call
+ * this on every frame: the "unchanged means no update" guard is what keeps a settled transition
+ * free.
+ * @param scene - The scene to dim, or a falsy value before one exists.
+ * @param value - The dim intensity, `0` to `1`.
+ * @returns Whether the root layer changed and so needs an update.
+ */
+export declare function applyVenueDim(scene: SceneDef | null | undefined, value: number): boolean;
+export declare function createDimmingAnimator(applyValue: (value: number) => void, durationMs?: number, easing?: DimmingEasing): DimmingAnimator;
+//# sourceMappingURL=dimming.d.ts.map

package/dist/esm/utils/dimming.js

@@ -0,0 +1,88 @@
+export const DIM_INTENSITY = 0.5;
+export const VENUE_DIM_INTENSITY = 1;
+export const DIM_TRANSITION_MS = 300;
+export const DEFAULT_DIM_EASING = 'cubic';
+/**
+ * Writes a venue-wide dim onto a scene's root layer, from which it descends to every layer and def
+ * that does not set a `dim` of its own.
+ *
+ * Only the write — the caller commits it through `update`, which is what lets an eased dim call
+ * this on every frame: the "unchanged means no update" guard is what keeps a settled transition
+ * free.
+ * @param scene - The scene to dim, or a falsy value before one exists.
+ * @param value - The dim intensity, `0` to `1`.
+ * @returns Whether the root layer changed and so needs an update.
+ */
+export function applyVenueDim(scene, value) {
+    if (!scene)
+        return false;
+    if (scene.rootLayer.dim === value)
+        return false;
+    scene.rootLayer.dim = value;
+    return true;
+}
+export function createDimmingAnimator(applyValue, durationMs = DIM_TRANSITION_MS, easing = DEFAULT_DIM_EASING) {
+    let animationFrameId = null;
+    let currentValue = 0;
+    let startValue = 0;
+    let targetValue = 0;
+    let startTime = 0;
+    const transitionDurationMs = Math.max(durationMs, 0);
+    function cancelAnimation() {
+        if (animationFrameId === null || typeof cancelAnimationFrame !== 'function')
+            return;
+        cancelAnimationFrame(animationFrameId);
+        animationFrameId = null;
+    }
+    function applyImmediate(value) {
+        cancelAnimation();
+        currentValue = value;
+        applyValue(currentValue);
+    }
+    function animate(now) {
+        const elapsed = now - startTime;
+        // A frame's timestamp is its start, which can precede the `performance.now()` read at
+        // `setTarget`; a negative progress would overshoot the value past its range.
+        const progress = Math.min(Math.max(elapsed / transitionDurationMs, 0), 1);
+        const easedProgress = easeProgress(progress, easing);
+        currentValue = startValue + (targetValue - startValue) * easedProgress;
+        applyValue(currentValue);
+        if (progress < 1) {
+            animationFrameId = requestAnimationFrame(animate);
+            return;
+        }
+        animationFrameId = null;
+        currentValue = targetValue;
+        applyValue(currentValue);
+    }
+    return {
+        getValue() {
+            return currentValue;
+        },
+        setTarget(dimmed, options = {}) {
+            const nextTargetValue = dimmed ? 1 : 0;
+            if (!options.immediate && nextTargetValue === targetValue && animationFrameId === null)
+                return;
+            targetValue = nextTargetValue;
+            if (options.immediate ||
+                transitionDurationMs === 0 ||
+                typeof requestAnimationFrame !== 'function') {
+                applyImmediate(targetValue);
+                return;
+            }
+            cancelAnimation();
+            startValue = currentValue;
+            startTime = typeof performance === 'undefined' ? Date.now() : performance.now();
+            animationFrameId = requestAnimationFrame(animate);
+        },
+        stop() {
+            cancelAnimation();
+        },
+    };
+}
+function easeProgress(t, easing) {
+    return easing === 'linear' ? t : easeInOutCubic(t);
+}
+function easeInOutCubic(t) {
+    return t < 0.5 ? 4 * t * t * t : 1 - Math.pow(-2 * t + 2, 3) / 2;
+}

package/dist/esm/utils/entity-storage.d.ts

@@ -0,0 +1,14 @@
+export interface EntityData {
+    exhibitors: number[];
+    events: number[];
+    speakers?: number[];
+    booths?: number[];
+}
+export type StorageType = 'bookmarked' | 'visited';
+export declare function getStorage(type: StorageType): EntityData;
+export declare function saveStorage(type: StorageType, data: EntityData): void;
+export declare function getBookmarkStorage(): EntityData;
+export declare function getVisitedStorage(): EntityData;
+export declare function saveBookmarkStorage(data: EntityData): void;
+export declare function saveVisitedStorage(data: EntityData): void;
+//# sourceMappingURL=entity-storage.d.ts.map

package/dist/esm/utils/entity-storage.js

@@ -0,0 +1,122 @@
+import { eventScopedCache } from '../tools/event-scoped-cache.js';
+import logger from '../tools/logger';
+import settings from '../tools/settings';
+import { isLocalStorageAvailable } from './localStorage';
+// Read back under `${settings.EXPO}-${type}`, so the entries belong to the
+// event they were read for — the next plan's bookmarks live under its own key
+// and must not be served this one's, hence per event (ADR-0011).
+const storageCache = eventScopedCache();
+function getStorageKey(type) {
+    return `${settings.EXPO}-${type}`;
+}
+function getFallbackKey(type) {
+    return type;
+}
+function getDefaultData(type) {
+    return type === 'bookmarked'
+        ? { exhibitors: [], events: [], speakers: [], booths: [] }
+        : { exhibitors: [], events: [] };
+}
+function migrateStorageData(type, parsed) {
+    if (parsed === null || parsed === undefined || typeof parsed !== 'object') {
+        logger.log(`Invalid ${type} data in localStorage - using defaults`);
+        return getDefaultData(type);
+    }
+    if (Array.isArray(parsed)) {
+        const migrated = type === 'bookmarked'
+            ? { exhibitors: parsed, events: [], speakers: [], booths: [] }
+            : { exhibitors: parsed, events: [] };
+        logger.log(`Migrated ${type} data from array to object format`);
+        saveStorage(type, migrated);
+        return migrated;
+    }
+    if (type === 'bookmarked') {
+        const result = parsed;
+        const updated = { ...result };
+        if (!('speakers' in updated)) {
+            updated.speakers = [];
+        }
+        if (!('booths' in updated)) {
+            updated.booths = [];
+        }
+        if (!result.speakers || !result.booths) {
+            logger.log(`Migrated ${type} data (added speakers or booths field)`);
+            saveStorage(type, updated);
+        }
+        return updated;
+    }
+    if (type === 'visited') {
+        const result = parsed;
+        return result;
+    }
+    logger.log(`Unsupported ${type} data format - using defaults`);
+    return getDefaultData(type);
+}
+export function getStorage(type) {
+    const cached = storageCache().get(type);
+    if (cached)
+        return cached;
+    const defaultData = getDefaultData(type);
+    if (!isLocalStorageAvailable) {
+        logger.warn(`localStorage unavailable — using default for ${type}`);
+        storageCache().set(type, defaultData);
+        return defaultData;
+    }
+    const storageKey = getStorageKey(type);
+    const fallbackKey = getFallbackKey(type);
+    let raw = null;
+    try {
+        raw = localStorage.getItem(storageKey) ?? localStorage.getItem(fallbackKey);
+    }
+    catch (e) {
+        logger.warn(`localStorage access error for ${type}`, e);
+    }
+    if (!raw) {
+        storageCache().set(type, defaultData);
+        return defaultData;
+    }
+    try {
+        const parsed = JSON.parse(raw);
+        const migrated = migrateStorageData(type, parsed);
+        storageCache().set(type, migrated);
+        return migrated;
+    }
+    catch (e) {
+        logger.error(`Error parsing ${type} data`, e);
+        storageCache().set(type, defaultData);
+        return defaultData;
+    }
+}
+export function saveStorage(type, data) {
+    if (!isLocalStorageAvailable)
+        return;
+    const storageKey = getStorageKey(type);
+    try {
+        localStorage.setItem(storageKey, JSON.stringify(data));
+        storageCache().set(type, data);
+        const logData = {
+            exhibitors: data.exhibitors.length,
+            events: data.events.length,
+        };
+        if (data.speakers)
+            logData.speakers = data.speakers.length;
+        if (data.booths)
+            logData.booths = data.booths.length;
+        logger.log(`save${type[0].toUpperCase() + type.slice(1)}ToLocalStorage`, logData);
+    }
+    catch (e) {
+        logger.error(`Failed to save ${type} data`, e);
+    }
+}
+export function getBookmarkStorage() {
+    return getStorage('bookmarked');
+}
+export function getVisitedStorage() {
+    return getStorage('visited');
+}
+export function saveBookmarkStorage(data) {
+    saveStorage('bookmarked', data);
+}
+export function saveVisitedStorage(data) {
+    saveStorage('visited', data);
+}

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

@@ -0,0 +1,38 @@
+/**
+ * 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 declare const MAX_DESCRIPTION = 160;
+interface EventHeadSource {
+    title: string;
+    subtitle: string;
+    locale: string;
+    exhibitors: readonly unknown[];
+    hideExhibitors: boolean;
+}
+export interface EventHead {
+    description: string;
+    /** Undefined when the event has no name to head the page with. */
+    heading: string | undefined;
+    /** Undefined unless `locale` is a well-formed BCP 47 tag. */
+    lang: string | undefined;
+}
+/** Cut to `max` characters on a word boundary, marking the cut with an ellipsis. */
+export declare function truncateAtWord(text: string, max: number): string;
+export declare function buildEventHead(source: EventHeadSource): EventHead;
+/** Write the event head into `doc`, filling only what the page lacks. */
+export declare function applyEventHead(doc: Document, head: EventHead, canonicalUrl: string): void;
+/**
+ * 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 declare function markNotIndexable(doc: Document): void;
+export {};
+//# sourceMappingURL=event-head.d.ts.map