@expofp/floorplan 0.0.0-experimental.cf063fc

package/dist/esm/utils/i18n.js

@@ -0,0 +1,117 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable @typescript-eslint/consistent-type-imports */
+// @ts-nocheck
+import { getConfig } from '@expofp/config';
+import i18next from 'i18next';
+import { observable } from 'mobx';
+import { LANGUAGE_TYPE } from '../constants';
+import localeMap from '../locales';
+import baseRuntimeUrl from '../tools/base-runtime-url';
+import { loadJson } from '../tools/loaders';
+import { isLocalStorageAvailable } from './localStorage';
+const DEFAULT_LOCALE = 'en';
+const STORAGE_KEY = 'efp-locale';
+const LEGACY_STORAGE_KEY = 'language';
+// Page-scoped, deliberately: the locale is the visitor's preference (stored,
+// or detected from the browser), not the event's — the event only supplies a
+// fallback, read per call in `detectLocale()`. `initI18n()` runs on every
+// `load()`, so a plan swap re-detects and re-populates both (ADR-0011).
+const currentLocale = observable.box(DEFAULT_LOCALE);
+const availableLocales = observable.array([], { deep: false });
+const loadTranslations = (locale) => loadJson(`${baseRuntimeUrl}locales/${locale}.json`);
+/** Reads the persisted locale, migrating from the legacy `language` key if needed. */
+const readStoredLocale = () => {
+    if (!isLocalStorageAvailable)
+        return null;
+    const stored = localStorage.getItem(STORAGE_KEY);
+    const legacy = localStorage.getItem(LEGACY_STORAGE_KEY);
+    // Always drop the legacy key once we've observed it, so it cannot linger alongside the new one.
+    if (legacy)
+        localStorage.removeItem(LEGACY_STORAGE_KEY);
+    if (stored)
+        return stored;
+    if (legacy)
+        localStorage.setItem(STORAGE_KEY, legacy);
+    return legacy;
+};
+const detectLocale = () => {
+    const browserLang = navigator.languages?.[0] || navigator.language;
+    const browserMatch = Object.keys(localeMap).find((id) => browserLang.startsWith(id));
+    return (readStoredLocale() || getConfig().locale || browserMatch || DEFAULT_LOCALE).toLowerCase();
+};
+export const getLocale = () => currentLocale.get();
+export const getLocales = () => availableLocales;
+export const hasLocale = (id) => availableLocales.some((l) => l.id === id);
+export const t = (template, options) => {
+    currentLocale.get(); // Subscribe to locale changes so MobX observers re-run on language switch.
+    return i18next.t(template, options);
+};
+/**
+ * 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 const tIfExists = (template, options) => {
+    currentLocale.get(); // Subscribe to locale changes so MobX observers re-run on language switch.
+    return i18next.exists(template, options) ? i18next.t(template, options) : template;
+};
+export const initI18n = async () => {
+    // localeMap keys and detectLocale() output are lowercase, so lowercasing the
+    // allowed list is enough to make uiLanguages matching case-insensitive.
+    const allowed = (getConfig().uiLanguages ?? []).map((id) => id.toLowerCase());
+    const isAllowed = (id) => allowed.length === 0 || allowed.includes(id);
+    availableLocales.replace(Object.entries(localeMap)
+        .filter(([id]) => isAllowed(id))
+        .sort(([a], [b]) => a.localeCompare(b))
+        .map(([id, name]) => ({ id, name, entity: { type: LANGUAGE_TYPE } })));
+    let locale = detectLocale();
+    if (!isAllowed(locale))
+        locale = availableLocales[0]?.id ?? DEFAULT_LOCALE;
+    const resources = {};
+    if (locale !== DEFAULT_LOCALE) {
+        try {
+            resources[locale] = { translation: await loadTranslations(locale) };
+        }
+        catch (err) {
+            console.error(`Unable to load "${locale}" localization, falling back to "${DEFAULT_LOCALE}".`, err);
+            locale = DEFAULT_LOCALE;
+        }
+    }
+    currentLocale.set(locale);
+    return i18next.init({
+        resources,
+        lng: locale,
+        keySeparator: false,
+        // English keys are the source strings, so "missing" is the normal case — only log for translated locales.
+        saveMissing: locale !== DEFAULT_LOCALE,
+        missingKeyHandler: (lngs, ns, key, fallbackValue) => console.debug(`i18n missing key: '${lngs[0]}:${ns}:${key}', fallback: '${fallbackValue}'`),
+    });
+};
+export const setLocale = async (id) => {
+    const locale = id.toLowerCase();
+    try {
+        if (locale !== DEFAULT_LOCALE && !i18next.hasResourceBundle(locale, 'translation')) {
+            i18next.addResourceBundle(locale, 'translation', await loadTranslations(locale), true, true);
+        }
+        await i18next.changeLanguage(locale);
+        currentLocale.set(locale);
+        if (isLocalStorageAvailable) {
+            localStorage.setItem(STORAGE_KEY, locale);
+        }
+    }
+    catch (err) {
+        // Swallow failures so callers can fire-and-forget; current selection is preserved
+        // because currentLocale is only mutated after the awaited load succeeds.
+        console.error(`Failed to switch language to "${locale}":`, err);
+    }
+};
+export const resetLocale = async () => {
+    if (isLocalStorageAvailable) {
+        localStorage.removeItem(STORAGE_KEY);
+        localStorage.removeItem(LEGACY_STORAGE_KEY);
+    }
+    return setLocale(detectLocale());
+};

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

@@ -0,0 +1,10 @@
+export declare function remsToPixels(rem: number): number;
+export declare function chunkArray<T>(array: T[], chunkSize: number): T[][];
+export declare function sortByName<T extends {
+    name: string;
+}>(arr: T[]): void;
+export declare const isWebGlSupported: boolean;
+export declare function shuffle<T>(array: T[]): T[];
+export declare function sleep(ms: any): Promise<void>;
+export * from './urlEncoding';
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/utils/index.js

@@ -0,0 +1,60 @@
+/* eslint-disable @typescript-eslint/no-explicit-any, no-var */
+// @ts-nocheck
+export function remsToPixels(rem) {
+    // TODO: touch store devicePixelRatio
+    return rem * parseFloat(getComputedStyle(document.documentElement).fontSize);
+}
+export function chunkArray(array, chunkSize) {
+    const chunks = [];
+    for (let i = 0; i < array.length; i += chunkSize) {
+        chunks.push(array.slice(i, i + chunkSize));
+    }
+    return chunks;
+}
+export function sortByName(arr) {
+    arr.sort(function (a, b) {
+        var x = a.name.toLowerCase();
+        var y = b.name.toLowerCase();
+        return x < y ? -1 : x > y ? 1 : 0;
+    });
+}
+const c = document.createElement('canvas');
+const gl = c.getContext('webgl') || c.getContext('experimental-webgl');
+export const isWebGlSupported = !!gl;
+if (!isWebGlSupported) {
+    const d = document.createElement('div');
+    d.innerHTML = '<!--no webgl-->';
+    document.body.appendChild(d);
+}
+export function shuffle(array) {
+    var currentIndex = array.length, temporaryValue, randomIndex;
+    // While there remain elements to shuffle...
+    while (0 !== currentIndex) {
+        // Pick a remaining element...
+        randomIndex = Math.floor(Math.random() * currentIndex);
+        currentIndex -= 1;
+        // And swap it with the current element.
+        temporaryValue = array[currentIndex];
+        array[currentIndex] = array[randomIndex];
+        array[randomIndex] = temporaryValue;
+    }
+    return array;
+}
+export function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+export * from './urlEncoding';
+// let isWebGlSupportedVal: boolean;
+// export function isWebGlSupported() {
+//     if (typeof isWebGlSupportedVal === "undefined") {
+//         const c = document.createElement("canvas");
+//         const gl = c.getContext("webgl") || (c.getContext("experimental-webgl") as any);
+//         isWebGlSupportedVal = !!gl;
+//         if (!isWebGlSupportedVal) {
+//             const d = document.createElement("div");
+//             d.innerHTML = "<!--no webgl-->";
+//             document.body.appendChild(d);
+//         }
+//     }
+//     return isWebGlSupportedVal;
+// }

package/dist/esm/utils/is-debug.d.ts

@@ -0,0 +1,3 @@
+declare const isDebug: boolean;
+export default isDebug;
+//# sourceMappingURL=is-debug.d.ts.map

package/dist/esm/utils/is-debug.js

@@ -0,0 +1,9 @@
+import { DEBUG_STORAGE_KEY } from '../constants';
+import { isLocalStorageAvailable } from './localStorage';
+// The `debugMode` config field, read straight off its localStorage key at
+// module init — long before `loadConfig` settles the effective config. The
+// debug panel edits the same key (its editor is derived from
+// LocalStorageConfigSchema); a data.js/manifest/options value only reaches
+// `getConfig().debugMode`, never this boot-time constant.
+const isDebug = isLocalStorageAvailable && localStorage.getItem(DEBUG_STORAGE_KEY) === 'true';
+export default isDebug;

package/dist/esm/utils/is-from-designer.d.ts

@@ -0,0 +1,3 @@
+declare const isFromDesigner: "" | boolean;
+export default isFromDesigner;
+//# sourceMappingURL=is-from-designer.d.ts.map

package/dist/esm/utils/is-from-designer.js

@@ -0,0 +1,4 @@
+const isFromDesigner = document.referrer &&
+    (document.referrer.indexOf('app.expofp.com') > -1 ||
+        document.referrer.indexOf('app-show.expofp.com') > -1);
+export default isFromDesigner;

package/dist/esm/utils/is-iframe.d.ts

@@ -0,0 +1,3 @@
+declare const val: boolean;
+export default val;
+//# sourceMappingURL=is-iframe.d.ts.map

package/dist/esm/utils/is-iframe.js

@@ -0,0 +1,13 @@
+import logger from '../tools/logger';
+function inIframe() {
+    try {
+        return window.self !== window.top;
+    }
+    catch (e) {
+        return true;
+    }
+}
+const val = inIframe();
+logger.log('Running in iframe: ', val);
+export default val;
+//https://stackoverflow.com/questions/326069/how-to-identify-if-a-webpage-is-being-loaded-inside-an-iframe-or-directly-into-t

package/dist/esm/utils/is-localhost.d.ts

@@ -0,0 +1,3 @@
+declare const isLocalhost: boolean;
+export default isLocalhost;
+//# sourceMappingURL=is-localhost.d.ts.map

package/dist/esm/utils/is-localhost.js

@@ -0,0 +1,11 @@
+const { hostname, protocol } = window.location;
+const isLocalhost = hostname === 'localhost' ||
+    hostname === '127.0.0.1' ||
+    hostname === '::1' ||
+    hostname.startsWith('192.168.') ||
+    hostname.startsWith('10.') ||
+    /^172\.(1[6-9]|2[0-9]|3[0-1])\./.test(hostname) ||
+    hostname.endsWith('.local') ||
+    protocol === 'file:' ||
+    hostname === '';
+export default isLocalhost;

package/dist/esm/utils/is-mac.d.ts

@@ -0,0 +1,3 @@
+declare const isMac: boolean;
+export default isMac;
+//# sourceMappingURL=is-mac.d.ts.map

package/dist/esm/utils/is-mac.js

@@ -0,0 +1,2 @@
+const isMac = navigator.platform.indexOf('Mac') > -1;
+export default isMac;

package/dist/esm/utils/is-mobile.d.ts

@@ -0,0 +1,3 @@
+declare const isMobile: boolean;
+export default isMobile;
+//# sourceMappingURL=is-mobile.d.ts.map

package/dist/esm/utils/is-mobile.js

@@ -0,0 +1,2 @@
+const isMobile = /Android|webOS|iPhone|iPad|iPod|BlackBerry|Opera Mini/i.test(navigator.userAgent);
+export default isMobile;

package/dist/esm/utils/is-own-domain.d.ts

@@ -0,0 +1,12 @@
+/** Pure so it's testable without stubbing `window.location`/`import.meta.env`. */
+export declare function computeIsOwnDomain(hostname: string, isDevServer: boolean): boolean;
+/**
+ * Whether we're allowed to mutate `document.title` on this page: true on our
+ * own event subdomains, false when `load()` mounted the SDK into a `<div>`
+ * on a third-party page with no iframe — same `document` as the host, and
+ * indistinguishable from a direct visit by `window.self === window.top`
+ * alone, so only the hostname tells them apart.
+ */
+declare const val: boolean;
+export default val;
+//# sourceMappingURL=is-own-domain.d.ts.map

package/dist/esm/utils/is-own-domain.js

@@ -0,0 +1,23 @@
+/// <reference types="vite/client" />
+import { OWN_APEX_DOMAINS } from './brand';
+// The apex domains themselves (listed in brand.ts) serve the marketing sites,
+// which don't depend on `@expofp/floorplan`. `fplan.io` also has per-event
+// subdomains, but they run a different engine (the `fest` repo) — this package
+// never executes there.
+/** Pure so it's testable without stubbing `window.location`/`import.meta.env`. */
+export function computeIsOwnDomain(hostname, isDevServer) {
+    if (isDevServer)
+        return true;
+    return OWN_APEX_DOMAINS.some((domain) => hostname.endsWith(`.${domain}`));
+}
+/**
+ * Whether we're allowed to mutate `document.title` on this page: true on our
+ * own event subdomains, false when `load()` mounted the SDK into a `<div>`
+ * on a third-party page with no iframe — same `document` as the host, and
+ * indistinguishable from a direct visit by `window.self === window.top`
+ * alone, so only the hostname tells them apart.
+ */
+const val = typeof window !== 'undefined' &&
+    // `import.meta.env` may not exist outside Vite (e.g. the unpkg/CDN build).
+    computeIsOwnDomain(window.location.hostname, !!import.meta.env?.DEV);
+export default val;

package/dist/esm/utils/is-pathway-layer.d.ts

@@ -0,0 +1,2 @@
+export declare function isPathwayLayer(name: string): boolean;
+//# sourceMappingURL=is-pathway-layer.d.ts.map

package/dist/esm/utils/is-pathway-layer.js

@@ -0,0 +1,4 @@
+import { PATHWAY_KEY } from '../constants';
+export function isPathwayLayer(name) {
+    return name.toLowerCase().includes(PATHWAY_KEY);
+}

package/dist/esm/utils/is-phone.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Whether this device is a phone, as opposed to a tablet or a kiosk panel that runs a mobile system.
+ *
+ * Measured on the device's screen rather than on the plan's container, so the answer is the same in
+ * either orientation, and whatever room a browser's toolbars or a host page leave the plan.
+ */
+declare const isPhone: boolean;
+export default isPhone;
+//# sourceMappingURL=is-phone.d.ts.map

package/dist/esm/utils/is-phone.js

@@ -0,0 +1,17 @@
+import isMobile from './is-mobile.js';
+import isWebview from './is-webview.js';
+/**
+ * The short side, in CSS pixels, from which a mobile device is a tablet rather than a phone. It is
+ * where Android itself draws that line (`sw600dp`); every iPad is well above it and every iPhone
+ * well below.
+ */
+const TABLET_MIN_SHORT_SIDE = 600;
+/**
+ * Whether this device is a phone, as opposed to a tablet or a kiosk panel that runs a mobile system.
+ *
+ * Measured on the device's screen rather than on the plan's container, so the answer is the same in
+ * either orientation, and whatever room a browser's toolbars or a host page leave the plan.
+ */
+const isPhone = (isMobile || isWebview) &&
+    Math.min(window.screen.width, window.screen.height) < TABLET_MIN_SHORT_SIDE;
+export default isPhone;

package/dist/esm/utils/is-scroll-ugly.d.ts

@@ -0,0 +1,3 @@
+declare const isScrollUgly: boolean;
+export default isScrollUgly;
+//# sourceMappingURL=is-scroll-ugly.d.ts.map

package/dist/esm/utils/is-scroll-ugly.js

@@ -0,0 +1,13 @@
+// @ts-nocheck
+const div = document.createElement('div');
+div.innerHTML = `<div style='height: 50px; width: 50px; overflow: scroll; visibility: hidden'>
+  <section style='height: 80px'></section>
+</div>`;
+document.body.appendChild(div);
+const d = div.getElementsByTagName('div')[0];
+const s = div.getElementsByTagName('section')[0];
+const isScrollUgly = d.offsetWidth > s.offsetWidth;
+//console.log("zzz", isScrollUgly, d.offsetWidth, s.offsetWidth);
+// __logger.log(d.offsetWidth, s.offsetWidth);
+document.body.removeChild(div);
+export default isScrollUgly;

package/dist/esm/utils/is-webview.d.ts

@@ -0,0 +1,3 @@
+declare const isWebview: boolean;
+export default isWebview;
+//# sourceMappingURL=is-webview.d.ts.map

package/dist/esm/utils/is-webview.js

@@ -0,0 +1,2 @@
+const isWebview = /webview|wv|ip((?!.*Safari)|(?=.*like Safari))|iosWebView|AndroidWebView/i.test(navigator.userAgent);
+export default isWebview;

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

@@ -0,0 +1,2 @@
+export declare const isNumericLevel: (level: string | undefined | null) => boolean;
+//# sourceMappingURL=isNumericLevel.d.ts.map

package/dist/esm/utils/isNumericLevel.js

@@ -0,0 +1,3 @@
+export const isNumericLevel = (level) => {
+    return !!level && /^\d+$/.test(level);
+};

package/dist/esm/utils/lazy-qr-code.d.ts

@@ -0,0 +1,5 @@
+import { type ComponentType } from 'react';
+import type { QRCodeProps } from 'react-qr-code';
+declare const QrCode: import("react").LazyExoticComponent<ComponentType<QRCodeProps>>;
+export default QrCode;
+//# sourceMappingURL=lazy-qr-code.d.ts.map

package/dist/esm/utils/lazy-qr-code.js

@@ -0,0 +1,6 @@
+import { lazy } from 'react';
+const QrCode = lazy(() => import('react-qr-code').then((mod) => ({
+    default: (mod.QRCode ??
+        mod.default),
+})));
+export default QrCode;

package/dist/esm/utils/legacy-storage-keys.d.ts

@@ -0,0 +1,16 @@
+/**
+ * One-shot boot migration of the pre-schema preference keys (`___viewer_mode`
+ * / `___preview_mode` / `___ui-scale`) to their schema-typed `efp-*`
+ * equivalents — the keys the debug panel edits and `UIState` prefers. Runs
+ * before anything reads the keys (`load()` calls it ahead of `loadConfig`).
+ *
+ * Copy, not move: the legacy keys stay in place for a release or two so a
+ * rollback to an older SDK still sees them (their readers keep a fallback);
+ * only an explicit disable/reset seed removes both generations. An existing
+ * `efp-*` value always wins — a stale legacy key must not clobber it.
+ *
+ * `storage` is injectable for tests; the default is the real `localStorage`
+ * when it is usable.
+ */
+export declare function migrateLegacyStorageKeys(storage?: Pick<Storage, 'getItem' | 'setItem'> | undefined): void;
+//# sourceMappingURL=legacy-storage-keys.d.ts.map

package/dist/esm/utils/legacy-storage-keys.js

@@ -0,0 +1,38 @@
+import { LEGACY_PREVIEW_MODE_STORAGE_KEY, LEGACY_UI_SCALE_STORAGE_KEY, LEGACY_VIEWER_MODE_STORAGE_KEY, PREVIEW_MODE_STORAGE_KEY, UI_SCALE_STORAGE_KEY, VIEWER_MODE_STORAGE_KEY, } from '../constants';
+import { isLocalStorageAvailable } from './localStorage';
+/**
+ * One-shot boot migration of the pre-schema preference keys (`___viewer_mode`
+ * / `___preview_mode` / `___ui-scale`) to their schema-typed `efp-*`
+ * equivalents — the keys the debug panel edits and `UIState` prefers. Runs
+ * before anything reads the keys (`load()` calls it ahead of `loadConfig`).
+ *
+ * Copy, not move: the legacy keys stay in place for a release or two so a
+ * rollback to an older SDK still sees them (their readers keep a fallback);
+ * only an explicit disable/reset seed removes both generations. An existing
+ * `efp-*` value always wins — a stale legacy key must not clobber it.
+ *
+ * `storage` is injectable for tests; the default is the real `localStorage`
+ * when it is usable.
+ */
+export function migrateLegacyStorageKeys(storage = isLocalStorageAvailable
+    ? localStorage
+    : undefined) {
+    if (!storage)
+        return;
+    // the legacy mode keys only ever store the enabled marker '1'
+    if (storage.getItem(LEGACY_VIEWER_MODE_STORAGE_KEY) === '1' &&
+        storage.getItem(VIEWER_MODE_STORAGE_KEY) === null) {
+        storage.setItem(VIEWER_MODE_STORAGE_KEY, 'true');
+    }
+    if (storage.getItem(LEGACY_PREVIEW_MODE_STORAGE_KEY) === '1' &&
+        storage.getItem(PREVIEW_MODE_STORAGE_KEY) === null) {
+        storage.setItem(PREVIEW_MODE_STORAGE_KEY, 'true');
+    }
+    // copied verbatim — both readers (the schema codec and UIState) validate
+    // the value themselves, so a hand-edited legacy value stays as harmless
+    // under the new key as it was under the old one
+    const legacyScale = storage.getItem(LEGACY_UI_SCALE_STORAGE_KEY);
+    if (legacyScale !== null && storage.getItem(UI_SCALE_STORAGE_KEY) === null) {
+        storage.setItem(UI_SCALE_STORAGE_KEY, legacyScale);
+    }
+}

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

@@ -0,0 +1,16 @@
+/**
+ * Fetches an image as a `Blob`, the form the renderer packs from.
+ *
+ * This function returns a `Blob`, not an `HTMLImageElement`, because decoding an image element
+ * blocks the main thread. At a thousand booth logos, the `HTMLImageElement` route stalls the
+ * thread for two seconds, and the `Blob` route does not stall it at all. A `Blob` is also a handle
+ * to bytes that do not change. A worker that receives one gets the handle, not a copy of the bytes.
+ *
+ * This function never throws. `normalize-legacy-data.ts` mints the `__small` and `__tiny` logo
+ * variants by adding a suffix to the full URL. It never confirms that the variant file exists. A
+ * 404 here is routine. When it happens, the caller retries with its fallback URL.
+ * @param src - The image URL.
+ * @returns The bytes, or `null` when the fetch fails.
+ */
+export declare function loadBlob(src: string): Promise<Blob | null>;
+//# sourceMappingURL=loadBlob.d.ts.map

package/dist/esm/utils/loadBlob.js

@@ -0,0 +1,40 @@
+/**
+ * Fetches an image as a `Blob`, the form the renderer packs from.
+ *
+ * This function returns a `Blob`, not an `HTMLImageElement`, because decoding an image element
+ * blocks the main thread. At a thousand booth logos, the `HTMLImageElement` route stalls the
+ * thread for two seconds, and the `Blob` route does not stall it at all. A `Blob` is also a handle
+ * to bytes that do not change. A worker that receives one gets the handle, not a copy of the bytes.
+ *
+ * This function never throws. `normalize-legacy-data.ts` mints the `__small` and `__tiny` logo
+ * variants by adding a suffix to the full URL. It never confirms that the variant file exists. A
+ * 404 here is routine. When it happens, the caller retries with its fallback URL.
+ * @param src - The image URL.
+ * @returns The bytes, or `null` when the fetch fails.
+ */
+export async function loadBlob(src) {
+    try {
+        // Fetch with `cors` and no credentials. This matches the `crossOrigin = 'anonymous'` that the
+        // image loader sets. The renderer reads the atlas back through a canvas, so a tainted response
+        // would break the whole floor plan. A `data:` URL ignores both options, because the browser
+        // serves it locally. So a drawing's inline base64 image still comes through unchanged.
+        const response = await fetch(src, { mode: 'cors', credentials: 'omit' });
+        if (!response.ok)
+            return null;
+        const blob = await response.blob();
+        // Reject anything that does not claim to be an image. `fetch` succeeds on requests that
+        // `<img>` used to fail on. For example, a fragment href such as `<image href="#defs">`
+        // resolves against the current document, so `fetch` answers with status 200 and the page's
+        // own HTML. This was measured, not assumed. The old `<img>` loader could not decode that
+        // HTML, so it dropped the image safely. A Blob would instead reach the renderer and throw at
+        // decode time.
+        //
+        // No sampled floor plan has an href like this. The resource walk in `@expofp/config` carries
+        // one fixture for the case, and three real drawings have none. So this guard is cheap
+        // insurance, and not a fix for a bug seen in real data.
+        return blob.type.startsWith('image/') ? blob : null;
+    }
+    catch {
+        return null;
+    }
+}

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

@@ -0,0 +1,3 @@
+import { type Config } from '@expofp/config';
+export declare function loadCustomCss(data: Config, appendTo: Element | ShadowRoot): Promise<void>;
+//# sourceMappingURL=loadCustomCss.d.ts.map

package/dist/esm/utils/loadCustomCss.js

@@ -0,0 +1,19 @@
+import { loadCustomFonts } from '../tools/loaders';
+export async function loadCustomCss(data, appendTo) {
+    if (data?.customCss) {
+        // Custom CSS must be injected at the document level: browsers ignore
+        // `@font-face` rules and `:root` custom properties (e.g. `--expofp-font-face`)
+        // declared inside a shadow root, so custom fonts would otherwise never load.
+        const style = document.createElement('style');
+        style.textContent = data.customCss;
+        document.head.append(style);
+        // When rendering inside a shadow root, inject a second copy so custom CSS that
+        // targets the shadow-scoped UI (component overrides) applies there too.
+        if (typeof ShadowRoot !== 'undefined' && appendTo instanceof ShadowRoot) {
+            const shadowStyle = document.createElement('style');
+            shadowStyle.textContent = data.customCss;
+            appendTo.append(shadowStyle);
+        }
+        await loadCustomFonts(data.customCss);
+    }
+}

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

@@ -0,0 +1,3 @@
+import { type FloorPlanIcon } from '../types';
+export declare function loadIcons(icons: Map<FloorPlanIcon, HTMLImageElement>): Promise<void>;
+//# sourceMappingURL=loadIcons.d.ts.map

package/dist/esm/utils/loadIcons.js

@@ -0,0 +1,24 @@
+import baseRuntimeUrl from '../tools/base-runtime-url';
+import { loadImage } from './loadImage';
+export async function loadIcons(icons) {
+    try {
+        const iconEntries = await Promise.allSettled(Object.entries({
+            departure: 'icons/departure.svg',
+            departure_inactive: 'icons/departure_inactive.svg',
+            destination: 'icons/destination.svg',
+            direction: 'icons/direction.svg',
+            transition: 'icons/transition.svg',
+            transition_up: 'icons/transition_up.svg',
+            transition_down: 'icons/transition_down.svg',
+            kiosk: 'icons/kiosk.svg',
+            yah: 'icons/yah.svg',
+        }).map(([key, path]) => loadImage(baseRuntimeUrl + path).then((image) => [key, image])));
+        iconEntries
+            .filter((entry) => entry.status === 'fulfilled')
+            .map((entry) => entry.value)
+            .forEach(([key, icon]) => icons.set(key, icon));
+    }
+    catch (e) {
+        console.warn(e);
+    }
+}

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

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

package/dist/esm/utils/loadImage.js

@@ -0,0 +1,11 @@
+/* eslint-disable no-var */
+// @ts-nocheck
+export function loadImage(src) {
+    return new Promise((resolve) => {
+        var img = new Image();
+        img.onerror = () => resolve(null);
+        img.onload = () => resolve(img);
+        img.crossOrigin = 'anonymous';
+        img.src = src;
+    });
+}

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

@@ -0,0 +1,22 @@
+export interface ImageUrls {
+    preferred?: string;
+    fallback: string;
+}
+export declare function loadImagesInBatchesById(logosUrls: Map<number, ImageUrls>, batchSize?: number, delay?: number): Promise<Map<number, HTMLImageElement>>;
+/**
+ * Loads a map of ids to image bytes. One URL loads at most once per call, no matter how many ids
+ * share it.
+ *
+ * This dedup is not an optimization. It is a correctness requirement. The renderer dedupes image
+ * sources by object identity, so two booths that share a logo must get the very same `Blob`
+ * object. If they do not, the logo downloads twice, packs twice, and draws from two atlas
+ * regions. The cache lives only for the length of this call, because the defs keep their own
+ * Blobs afterward. A cache that outlived the call would give every logo on the plan a second
+ * place to stay in memory.
+ * @param logosUrls - The URLs to load, keyed by booth id.
+ * @param batchSize - How many URLs to load at once.
+ * @param delay - Milliseconds to wait between batches.
+ * @returns The bytes, keyed by booth id. An id is absent when its logo failed to load.
+ */
+export declare function loadBlobsInBatchesById(logosUrls: Map<number, ImageUrls>, batchSize?: number, delay?: number): Promise<Map<number, Blob>>;
+//# sourceMappingURL=loadImagesInBatches.d.ts.map