@expofp/floorplan 0.0.0-experimental.2632d13

package/dist/esm/tools/style-registry.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Where the chunk-injected `<style>` elements live between plans.
+ *
+ * A chunk injects its CSS once per page, when it first evaluates
+ * (`vite/per-chunk-css-injection.ts`), so the elements have to outlive every
+ * plan: it registers each one on `window.__efpStyleElements`, and
+ * `floorplan.loader` adopts the whole registry into each new container —
+ * `appendChild` *moving* every element out of the previous, discarded one.
+ * That migration is why a swap leaves the node count flat instead of stacking
+ * a stylesheet set per generation, and it is why `resetGlobalVariables()`
+ * deliberately skips this one key.
+ *
+ * It has one edge, though, and only on the destroy that no `load()` follows:
+ * the registry still points at elements whose parent is the dead plan's
+ * ShadowRoot. A node keeps its parent reachable, so a single adopted `<style>`
+ * pins that root, its host and the ~7,200-node tree under it for the life of
+ * the page.
+ *
+ * Parking cuts that edge without giving up re-adoption.
+ */
+/**
+ * Moves every registered `<style>` out of the container being torn down and
+ * into {@link parkingLot}, leaving `window.__efpStyleElements` itself intact —
+ * the next `load()` adopts them out of the holder exactly as it would out of a
+ * previous plan's container.
+ */
+export declare function parkRegisteredStyles(): void;
+//# sourceMappingURL=style-registry.d.ts.map

package/dist/esm/tools/style-registry.js

@@ -0,0 +1,46 @@
+/**
+ * Where the chunk-injected `<style>` elements live between plans.
+ *
+ * A chunk injects its CSS once per page, when it first evaluates
+ * (`vite/per-chunk-css-injection.ts`), so the elements have to outlive every
+ * plan: it registers each one on `window.__efpStyleElements`, and
+ * `floorplan.loader` adopts the whole registry into each new container —
+ * `appendChild` *moving* every element out of the previous, discarded one.
+ * That migration is why a swap leaves the node count flat instead of stacking
+ * a stylesheet set per generation, and it is why `resetGlobalVariables()`
+ * deliberately skips this one key.
+ *
+ * It has one edge, though, and only on the destroy that no `load()` follows:
+ * the registry still points at elements whose parent is the dead plan's
+ * ShadowRoot. A node keeps its parent reachable, so a single adopted `<style>`
+ * pins that root, its host and the ~7,200-node tree under it for the life of
+ * the page.
+ *
+ * Parking cuts that edge without giving up re-adoption.
+ */
+/**
+ * The plan-independent holder the styles wait in. A `DocumentFragment` because
+ * it is a parent that belongs to nothing: not in any document, so the CSS
+ * applies to nothing while it sits here (`document.head` would keep the styles
+ * alive just as well, and leak the plan's CSS onto the host page for as long as
+ * no plan is loaded), and reachable only from this module, so the array
+ * transitively holds nothing but the styles themselves.
+ */
+let parkingLot;
+/**
+ * Moves every registered `<style>` out of the container being torn down and
+ * into {@link parkingLot}, leaving `window.__efpStyleElements` itself intact —
+ * the next `load()` adopts them out of the holder exactly as it would out of a
+ * previous plan's container.
+ */
+export function parkRegisteredStyles() {
+    const registered = window.__efpStyleElements;
+    if (!registered || registered.length === 0)
+        return;
+    if (!parkingLot) {
+        parkingLot = document.createDocumentFragment();
+    }
+    for (const element of registered) {
+        parkingLot.appendChild(element);
+    }
+}

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

@@ -0,0 +1,37 @@
+export interface TelemetryEvent {
+    type: string;
+    value: string;
+    /** Narrows `type` — e.g. which kind of entity a `bookmark` event refers to. */
+    subtype?: string;
+    /** ISO string */
+    timestamp: string;
+    url: string;
+    referrer: string;
+}
+export interface TelemetryPayload {
+    expo: string;
+    expoId?: number;
+    kioskId: string;
+    items: TelemetryEvent[];
+}
+export interface TelemetryStorage {
+    get(): TelemetryPayload | null;
+    set(data: TelemetryPayload): void;
+    clear(): void;
+}
+export interface TelemetryConfig {
+    url: string;
+    expo: string;
+    /** @deprecated switch to using `expo` when backend is ready (TODO: remove after 2027-01-01) */
+    expoId?: number;
+    kioskId?: string;
+    storage?: TelemetryStorage;
+}
+export interface TelemetryClient {
+    enqueue(event: TelemetryEvent): void;
+    send(event: TelemetryEvent): Promise<void>;
+    flush(): Promise<void>;
+    setKioskId(kioskId: string): void;
+}
+export declare function createTelemetry(config: TelemetryConfig): TelemetryClient;
+//# sourceMappingURL=telemetry.d.ts.map

package/dist/esm/tools/telemetry.js

@@ -0,0 +1,266 @@
+const EFP_TELEMETRY = 'efp-telemetry';
+const MAX_RETRY_AFTER_MS = 5 * 60 * 1000; // 5 minutes
+const MAX_STORED_EVENTS = 1000;
+/**
+ * `fetch` refuses `keepalive` above 64 KB, and the larger a body the likelier
+ * an endpoint rejects it outright — a rejection no backoff can resolve, which
+ * would return the same oversized batch to storage forever. A flush therefore
+ * posts several batches under this limit rather than the whole backlog at once.
+ */
+const MAX_BODY_BYTES = 63_000;
+/**
+ * One key per expo. A batch can outlive the plan that produced it — a flush
+ * still in flight, one held back by a Retry-After, or one restored after a
+ * failed POST — and a shared key let the next plan's client adopt it and
+ * re-stamp it with its own expo. Keyed this way a stranded batch stays
+ * labelled, and is only ever picked up by a client for the same expo.
+ */
+function storageKey(expo) {
+    return expo ? `${EFP_TELEMETRY}:${expo}` : EFP_TELEMETRY;
+}
+function createLocalStorage(key = EFP_TELEMETRY) {
+    return {
+        get() {
+            try {
+                const stored = localStorage.getItem(key);
+                return stored ? JSON.parse(stored) : null;
+            }
+            catch {
+                return null;
+            }
+        },
+        set(data) {
+            try {
+                localStorage.setItem(key, JSON.stringify(data));
+            }
+            catch (e) {
+                console.error('Failed to persist telemetry data', e);
+            }
+        },
+        clear() {
+            try {
+                localStorage.removeItem(key);
+            }
+            catch (e) {
+                console.error('Failed to clear telemetry data', e);
+            }
+        },
+    };
+}
+/**
+ * Mirrors the expo key into the POST query string so the backend can route the
+ * batch without parsing the body; the payload still carries `expo` as before.
+ *
+ * Hand-rolled rather than `URL`-based because the base may be relative, which
+ * `URL` cannot parse without a base document. Any fragment is preserved and
+ * kept last — appending after it would bury the query inside the fragment.
+ */
+function buildPostUrl(base, expo) {
+    if (!expo)
+        return base;
+    const hashAt = base.indexOf('#');
+    const target = hashAt === -1 ? base : base.slice(0, hashAt);
+    const hash = hashAt === -1 ? '' : base.slice(hashAt);
+    let separator = '?';
+    if (target.includes('?')) {
+        separator = target.endsWith('?') || target.endsWith('&') ? '' : '&';
+    }
+    return `${target}${separator}expo=${encodeURIComponent(expo)}${hash}`;
+}
+/**
+ * Takes the longest run of leading events whose JSON body stays within
+ * `MAX_BODY_BYTES`, already serialized so the caller never re-encodes it.
+ * Events vary in size, so the run grows by measured bytes rather than by count.
+ *
+ * Measuring event by event rather than serializing the whole queue to see
+ * whether it fits is what keeps a drain linear: the queue is re-read for every
+ * batch, so a "does it all fit?" check would re-encode the entire remainder
+ * once per batch and turn a large backlog quadratic.
+ *
+ * A lone event larger than the limit is still returned on its own: dropping it
+ * here would lose data silently, and the caller drops it only once the endpoint
+ * has actually refused it.
+ */
+function takeBatch(data) {
+    const encoder = new TextEncoder();
+    const items = [];
+    let bytes = encoder.encode(JSON.stringify({ ...data, items: [] })).byteLength;
+    for (const item of data.items) {
+        const itemBytes = encoder.encode(JSON.stringify(item)).byteLength;
+        // Every item but the first costs one more byte for the comma joining it to
+        // the one before, so `bytes` matches what JSON.stringify would produce.
+        const cost = items.length > 0 ? itemBytes + 1 : itemBytes;
+        if (items.length > 0 && bytes + cost > MAX_BODY_BYTES)
+            break;
+        bytes += cost;
+        items.push(item);
+    }
+    // Whole queue fits: send it as it is rather than copying it to say the same.
+    const payload = items.length === data.items.length ? data : { ...data, items };
+    return { payload, body: JSON.stringify(payload), bytes };
+}
+/**
+ * Whether the endpoint has refused a batch for good. Waiting cannot change the
+ * answer to any of these, so the batch is dropped instead of retried forever —
+ * one undeliverable batch must not block every event queued behind it. 408 and
+ * 429 are the 4xx codes that do mean "try again", and 5xx are transient.
+ */
+function isPermanentRejection(status) {
+    return status >= 400 && status < 500 && status !== 408 && status !== 429;
+}
+/**
+ * Caps the queue, dropping the oldest events — the same policy as `enqueue`, so
+ * a batch that failed is never kept in preference to fresher data. Reports what
+ * it drops; at the cap the loss is otherwise silent.
+ */
+function capItems(items) {
+    if (items.length <= MAX_STORED_EVENTS)
+        return items;
+    console.warn(`Telemetry queue full: dropping ${items.length - MAX_STORED_EVENTS} oldest events`);
+    return items.slice(-MAX_STORED_EVENTS);
+}
+function parseRetryAfter(response) {
+    const header = response.headers.get('Retry-After');
+    if (!header)
+        return 0;
+    let ms = 0;
+    const seconds = Number(header);
+    if (Number.isFinite(seconds)) {
+        ms = seconds * 1000;
+    }
+    else {
+        const date = Date.parse(header);
+        if (!isNaN(date))
+            ms = Math.max(0, date - Date.now());
+    }
+    return Math.min(ms, MAX_RETRY_AFTER_MS);
+}
+export function createTelemetry(config) {
+    const { url, expo, expoId, storage = createLocalStorage(storageKey(expo)) } = config;
+    const postUrl = buildPostUrl(url, expo);
+    // Canonical kioskId — always used as the single source of truth
+    let kioskId = config.kioskId ?? '';
+    function getData() {
+        const stored = storage.get();
+        if (stored) {
+            stored.expo = expo;
+            stored.expoId = expoId;
+            stored.kioskId = kioskId;
+            return stored;
+        }
+        return { expo, expoId, kioskId, items: [] };
+    }
+    function setKioskId(id) {
+        kioskId = id;
+    }
+    let flushing = false;
+    let pendingFlush = false;
+    // Retry-After deadline tracked via performance.now() (monotonic clock)
+    // so system clock changes or NTP corrections can't skip or extend the backoff.
+    let retryUntil = 0;
+    async function flush() {
+        if (flushing) {
+            pendingFlush = true;
+            return;
+        }
+        flushing = true;
+        try {
+            do {
+                pendingFlush = false;
+                if (performance.now() < retryUntil)
+                    break;
+                // Events handed to a request that storage no longer holds. Restored if
+                // that request throws; null whenever storage owns them instead.
+                let inFlight = null;
+                try {
+                    // Only what was queued when this flush began. Events enqueued during
+                    // the drain are left to the next flush, so a page producing events
+                    // faster than they send cannot keep the loop below running.
+                    let budget = getData().items.length;
+                    while (budget > 0) {
+                        const stored = getData();
+                        if (stored.items.length === 0)
+                            break;
+                        const { payload, body, bytes } = takeBatch(stored);
+                        const count = payload.items.length;
+                        // Remove the batch from storage before sending it, so storage
+                        // always holds exactly what has not been dispatched — a teardown
+                        // mid-drain cannot take the remainder with it. Delivery is
+                        // at-most-once by design: events carry no id, so a resend would
+                        // double-count rather than de-duplicate.
+                        saveItems(stored, stored.items.slice(count));
+                        inFlight = payload.items;
+                        budget -= count;
+                        const response = await fetch(postUrl, {
+                            method: 'POST',
+                            body,
+                            headers: { 'Content-Type': 'application/json' },
+                            credentials: 'omit',
+                            // Only a lone event too large to fit on its own exceeds this.
+                            keepalive: bytes <= MAX_BODY_BYTES,
+                        });
+                        // Reading the body to completion is what closes the request's fetch
+                        // record and returns its share of the 64 KiB keepalive quota, which
+                        // is shared across the whole document. Skip it and every batch after
+                        // the first is refused outright with a network error — measured in
+                        // Chrome 152: 1 of 8 delivered without this, 20 of 20 with it.
+                        // Best-effort: a torn-down response must not fail a delivered batch.
+                        await response.text().catch(() => undefined);
+                        inFlight = null;
+                        if (!response.ok) {
+                            if (isPermanentRejection(response.status)) {
+                                console.error(`Telemetry batch refused by the endpoint: HTTP ${response.status} ` +
+                                    `(dropped: ${count})`);
+                                continue;
+                            }
+                            if (response.status === 429 || response.status === 503) {
+                                const delay = parseRetryAfter(response);
+                                if (delay > 0) {
+                                    retryUntil = performance.now() + delay;
+                                }
+                            }
+                            restoreItems(payload.items);
+                            console.error(`Failed to send telemetry: HTTP ${response.status} (requeued: ${count})`);
+                            break;
+                        }
+                    }
+                }
+                catch (e) {
+                    // Only ever the one batch storage gave up; a throw before that leaves
+                    // storage untouched, so there is nothing to put back.
+                    if (inFlight)
+                        restoreItems(inFlight);
+                    console.error('Failed to send telemetry', e);
+                }
+            } while (pendingFlush);
+        }
+        finally {
+            // A throw anywhere above — including from a host-supplied `storage` in
+            // the failure path — must not leave the client permanently flushing.
+            flushing = false;
+        }
+    }
+    /** Writes `items` back as the whole queue, clearing the key when it is empty. */
+    function saveItems(data, items) {
+        if (items.length === 0)
+            storage.clear();
+        else
+            storage.set({ ...data, items });
+    }
+    function restoreItems(failed) {
+        if (failed.length === 0)
+            return;
+        const current = getData();
+        saveItems(current, capItems([...failed, ...current.items]));
+    }
+    function enqueue(event) {
+        const data = getData();
+        data.items.push(event);
+        saveItems(data, capItems(data.items));
+    }
+    async function send(event) {
+        enqueue(event);
+        await flush();
+    }
+    return { enqueue, send, flush, setKioskId };
+}

package/dist/esm/tools/track-event.d.ts

@@ -0,0 +1,28 @@
+type TrackEventType = 'load' | 'exview' | 'search' | 'route' | 'share' | 'booview' | 'catview' | 'ws_exhibitor_click' | 'sesview' | 'bookmark' | 'spkview' | 'sbtnview';
+/** Which kind of entity a `bookmark` event refers to. */
+export type TrackEventBookmarkSubtype = 'booth' | 'exhibitor' | 'session' | 'speaker';
+/**
+ * Which button surface an `sbtnview` came from. The main row above the plan
+ * sends none, so its series is unchanged; the surfaces added later are
+ * distinguishable instead of being silently mixed into the same counter.
+ */
+export type TrackEventButtonSubtype = 'subbutton' | 'shortcut';
+export type TrackEventSubtype = TrackEventBookmarkSubtype | TrackEventButtonSubtype;
+export default function trackEvent(type: TrackEventType, value?: any, subtype?: TrackEventSubtype): Promise<void>;
+/**
+ * Drops the module-scope telemetry state — the client (with its cached expo,
+ * expoId and kioskId) and the one-shot migration flag. `unstable_destroy()`
+ * tears down the DOM and the stores, but ES module state outlives it, so
+ * without this a host that destroys the plan and loads a different one keeps
+ * reporting under the first plan's event.
+ *
+ * Anything the client still had queued is drained first: it belongs to the
+ * plan being torn down. That drain is best-effort — `flush()` is async and
+ * can return early — so it is not what stops the batch being credited to the
+ * next plan; the per-expo storage key is. A batch restored after a failed
+ * POST keeps its own expo's key and waits for the next client for that expo,
+ * instead of being adopted and relabelled by a different one.
+ */
+export declare function resetTelemetry(): void;
+export {};
+//# sourceMappingURL=track-event.d.ts.map

package/dist/esm/tools/track-event.js

@@ -0,0 +1,196 @@
+import { peekConfig } from '@expofp/config';
+import { createKiosk } from '../components/Kiosk/kioskApi';
+import { getSavedKiosk } from '../components/Kiosk/SetKiosk';
+import { KIOSK_STATS_ID_STORAGE_KEY } from '../components/Kiosk/SetKiosk/constants';
+import { registerPlanDisposer } from '../plan-lifecycle.js';
+import { getLocationHistory } from '../services/url-sync';
+import { uiState } from '../store';
+import logger from './logger';
+import { createTelemetry } from './telemetry';
+let telemetryClient;
+/** The `__efpEvent` the cached client was built for — see `getTelemetryClient`. */
+let telemetryClientExpo;
+/**
+ * The client is cached per expo, not once per document: `unstable_destroy()`
+ * cannot be relied on to have reset it (a timer that outlives the teardown can
+ * rebuild one first, and `resetGlobalVariables` has deleted `__efpEvent` by
+ * then). Keying the cache means a client built for the wrong — or missing —
+ * expo is replaced as soon as the right one is known, instead of being
+ * memoized for the rest of the document's life.
+ */
+function getTelemetryClient() {
+    const expo = window['__efpEvent'];
+    if (telemetryClient && telemetryClientExpo === expo)
+        return telemetryClient;
+    // Whatever the previous client queued belongs to ITS expo, so drain it
+    // before swapping. That drain is best-effort: `flush()` returns without
+    // clearing storage when one is already in flight or a Retry-After backoff
+    // is active. What actually keeps the batches apart is the per-expo storage
+    // key — the new client reads its own, and starts from an empty queue.
+    telemetryClient?.flush();
+    let expoId;
+    try {
+        const raw = new URL(peekConfig()?.trackerUrl ?? '').searchParams.get('expoId');
+        expoId = raw ? Number(raw) : undefined;
+    }
+    catch (err) {
+        logger.error(err);
+    }
+    telemetryClient = createTelemetry({ url: 'https://app.expofp.com/api/telemetry', expo, expoId });
+    telemetryClientExpo = expo;
+    // The client is the plan's: flushed and dropped with it, wherever it was first needed.
+    registerPlanDisposer(resetTelemetry);
+    return telemetryClient;
+}
+function makeEvent(type, value, subtype) {
+    const history = getLocationHistory();
+    const prev = history[history.length - 2];
+    return {
+        type,
+        subtype,
+        // `== null` on purpose: a missing value must serialize as '', never as
+        // the string 'null' — legacy providers hand out null as often as undefined.
+        value: value == null ? '' : String(value),
+        timestamp: new Date().toISOString(),
+        url: window.location.href,
+        referrer: prev ? window.location.origin + prev : '',
+    };
+}
+function isTrackingEnabled() {
+    // `__efpEvent` is set by `load()` before the first event and deleted by
+    // `unstable_destroy()`, so it doubles as "a plan is live": a timer that
+    // fires after teardown has no plan to report under and must stay silent.
+    return (!!window['__efpEvent'] &&
+        !!peekConfig()?.trackerUrl &&
+        process.env.NODE_ENV === 'production' &&
+        !uiState.heatmap);
+}
+export default async function trackEvent(type, value, subtype) {
+    logger.log('trackEvent', type, value, subtype);
+    if (!isTrackingEnabled())
+        return;
+    try {
+        // Stamped before the kiosk branch below, which can await a network round
+        // trip: `timestamp` and `url` must describe the interaction, not whenever
+        // the request that carries it happens to go out.
+        const event = makeEvent(type, value, subtype);
+        const kiosk = getSavedKiosk();
+        let kioskId = null;
+        if (kiosk) {
+            kioskId = await resolveKioskId(kiosk);
+        }
+        else {
+            localStorage.removeItem(KIOSK_STATS_ID_STORAGE_KEY);
+        }
+        // The gate ran before the kiosk round trip above; re-check it now. A
+        // teardown landing inside that await leaves no live plan to report under,
+        // and building a client here would resurrect the module state
+        // `resetTelemetry()` had just cleared — with an empty expo, because
+        // `resetGlobalVariables()` has already deleted `__efpEvent`.
+        if (!isTrackingEnabled())
+            return;
+        // Resolved after that await, never before it: a destroy + load in between
+        // makes a different plan the live one, and the event has to go out under
+        // whichever client is current when it is actually sent.
+        const client = getTelemetryClient();
+        if (kiosk && !kioskId) {
+            client.enqueue(event);
+            return;
+        }
+        // The telemetry client also caches kioskId in-memory (the source of
+        // truth in getData()), so clearing localStorage alone would keep
+        // tagging events with the stale id after the user leaves kiosk mode.
+        client.setKioskId(kioskId ?? '');
+        migrateOldEvents(client);
+        await client.send(event);
+    }
+    catch (e) {
+        logger.error('trackEvent', String(e));
+    }
+}
+/** The create-kiosk request in flight, if any — see `resolveKioskId`. */
+let kioskIdRequest;
+async function resolveKioskId(kiosk) {
+    if (!kiosk)
+        return null;
+    const saved = localStorage.getItem(KIOSK_STATS_ID_STORAGE_KEY);
+    if (saved)
+        return saved;
+    // Two events raised in one tick (a bookmark click reports both its own
+    // event and the GA one) would otherwise each POST with no key and have the
+    // backend mint a kiosk record apiece. Share the first request instead; it is
+    // cleared once settled so a failed create can still be retried later.
+    if (!kioskIdRequest) {
+        // `createKiosk` bakes the current `__efpEvent` into its URL, so the record
+        // it mints belongs to the plan that started the request. The handle is
+        // module state that outlives a teardown, so if a destroy + load swaps the
+        // plan mid-flight that key must be neither saved nor returned: the next
+        // event for the new plan finds no request pending and mints its own.
+        const requestedFor = window['__efpEvent'];
+        kioskIdRequest = createKiosk(kiosk, 'https://app.expofp.com/')
+            .then((key) => {
+            if (!key || window['__efpEvent'] !== requestedFor)
+                return null;
+            localStorage.setItem(KIOSK_STATS_ID_STORAGE_KEY, key);
+            return key;
+        })
+            .finally(() => {
+            kioskIdRequest = undefined;
+        });
+    }
+    return kioskIdRequest;
+}
+let migrated = false;
+/**
+ * Drops the module-scope telemetry state — the client (with its cached expo,
+ * expoId and kioskId) and the one-shot migration flag. `unstable_destroy()`
+ * tears down the DOM and the stores, but ES module state outlives it, so
+ * without this a host that destroys the plan and loads a different one keeps
+ * reporting under the first plan's event.
+ *
+ * Anything the client still had queued is drained first: it belongs to the
+ * plan being torn down. That drain is best-effort — `flush()` is async and
+ * can return early — so it is not what stops the batch being credited to the
+ * next plan; the per-expo storage key is. A batch restored after a failed
+ * POST keeps its own expo's key and waits for the next client for that expo,
+ * instead of being adopted and relabelled by a different one.
+ */
+export function resetTelemetry() {
+    telemetryClient?.flush();
+    telemetryClient = undefined;
+    telemetryClientExpo = undefined;
+    migrated = false;
+}
+function migrateOldEvents(client) {
+    if (migrated)
+        return;
+    migrated = true;
+    const EFP_TRACK_EVENTS = 'efp-track-events';
+    try {
+        const saved = localStorage.getItem(EFP_TRACK_EVENTS);
+        if (!saved)
+            return;
+        const events = JSON.parse(saved);
+        if (!Array.isArray(events)) {
+            // Invalid format, just clear it
+            localStorage.removeItem(EFP_TRACK_EVENTS);
+            return;
+        }
+        for (const event of events) {
+            if (!event || typeof event !== 'object' || !event.headers)
+                continue;
+            client.enqueue({
+                type: event.type,
+                value: event.value == null ? '' : String(event.value),
+                timestamp: event.timeStamp,
+                url: event.headers['X-href'],
+                referrer: event.headers['X-ref'] ?? '',
+            });
+        }
+        localStorage.removeItem(EFP_TRACK_EVENTS);
+    }
+    catch (e) {
+        localStorage.removeItem(EFP_TRACK_EVENTS);
+        logger.error('Failed to migrate old events.', String(e));
+    }
+}

package/dist/esm/tools/webgl-logger.d.ts

@@ -0,0 +1,2 @@
+export declare function logBuffer(bytes: number, category: string): void;
+//# sourceMappingURL=webgl-logger.d.ts.map

package/dist/esm/tools/webgl-logger.js

@@ -0,0 +1,31 @@
+/* eslint-disable prefer-const */
+// @ts-nocheck
+import logger from './logger';
+let loadedBytes = 0;
+let loggedMb = 0;
+const loggedByCategory = new Map();
+let logFinishedTimeout;
+export function logBuffer(bytes, category) {
+    loadedBytes += bytes;
+    let categoryBytes = loggedByCategory.get(category) || 0;
+    loggedByCategory.set(category, categoryBytes + bytes);
+    log(false);
+    if (logFinishedTimeout)
+        clearTimeout(logFinishedTimeout);
+    logFinishedTimeout = setTimeout(() => log(true), 5000);
+}
+function log(finished) {
+    const loadedMbRounded = Math.floor(loadedBytes / 1024 / 1024);
+    // log every 10MB
+    if (finished || loadedMbRounded > loggedMb + 10) {
+        loggedMb = loadedMbRounded;
+        const catLogMessage = Array.from(loggedByCategory.entries())
+            .map(([key, value]) => {
+            const roundedMb = Math.floor(value / 1024 / 1024);
+            return `${key}: ${roundedMb}MB`;
+        })
+            .join(', ');
+        logger.log(`${finished ? 'Finished ' : ''}GPU: ${loadedMbRounded}MB, ${catLogMessage}`);
+    }
+}
+//4029410018626614;

package/dist/esm/types/drawing.types.d.ts

@@ -0,0 +1,18 @@
+import { type ColorInput, type ShapeDef } from '@expofp/renderer';
+/**
+ * Drawing-side shape types, formerly declared in the retired `data/Data.d.ts`
+ * (the event-data types now live on `@expofp/config`; these two are renderer
+ * concepts, not data-document fields).
+ */
+/** A renderer shape with the floorplan painters' background extensions. */
+export interface ShapeBgDef extends ShapeDef {
+    defaultColor?: ColorInput;
+    unblinking?: boolean;
+}
+/** One highlighted booth path (by SVG `data-index`), as the painters consume it. */
+export interface PathInfo {
+    index: number;
+    color: string;
+    unblinking: boolean;
+}
+//# sourceMappingURL=drawing.types.d.ts.map

package/dist/esm/types/drawing.types.js

@@ -0,0 +1 @@
+export {};