@expofp/floorplan 0.0.0-experimental.2d6c681

package/dist/esm/tools/report-error.js

@@ -0,0 +1,134 @@
+// @ts-nocheck
+import logger from './logger';
+let timeoutId;
+export default function reportError(e) {
+    if (timeoutId || e.filename.indexOf('expofp.com') === -1)
+        return;
+    const ignoredErrors = [
+        /loading chunk \d{1,2}\b/i,
+        /zaloJS/i,
+        /e.target.name/i,
+        /ResizeObserver loop/i,
+        /ChunkLoadError/i,
+        /FloorPlan not ready/i,
+    ];
+    const ignoreError = ignoredErrors.some((err) => err.test(e.message));
+    if (ignoreError)
+        return;
+    timeoutId = window.setTimeout(async function () {
+        //const ipData = await getIpData();
+        const language = navigator.languages && navigator.languages.length
+            ? navigator.languages[0]
+            : navigator.language;
+        const data = {
+            host: document.location.host,
+            message: e.message,
+            filename: e.filename,
+            lineno: e.lineno,
+            colno: e.colno,
+            stack: e.error?.stack,
+            log: logger.messages.join('\n'),
+            userAgent: navigator.userAgent,
+            language,
+            group: 'FP',
+            url: document.location,
+            subject: 'FP JS error: ' + document.location.host, // + " in " + ipData.country,
+            //...ipData
+        };
+        logger.info('Sending error report', data);
+        await Promise.all([sendEmailMessage(data), sendSlackMessage(data)]);
+    }, 2000);
+}
+async function sendEmailMessage(data) {
+    if (process.env.NODE_ENV !== 'production')
+        return;
+    const rawResponse = await fetch('https://app.expofp.com/api/report-error', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(data),
+    });
+    logger.log('Reporter response: ', await rawResponse.text());
+}
+async function sendSlackMessage(data) {
+    if (process.env.NODE_ENV !== 'production')
+        return;
+    const slackObj = createSlackMessage(data);
+    const rawResponse = await fetch('https://msg.expofp.com/v1/post-message/' + window.location.hostname, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(slackObj),
+    });
+    logger.log('Slack reporter response: ', await rawResponse.text());
+}
+// sendSlackMessage({
+//     subject: "123",
+//     someData: "123",
+//     someData2: "123"
+// });
+function createSlackMessage(data) {
+    const blocksData = JSON.parse(JSON.stringify(data));
+    delete blocksData.subject;
+    delete blocksData.message;
+    delete blocksData.stack;
+    delete blocksData.log;
+    const blocks = [];
+    blocks.push({
+        type: 'section',
+        text: {
+            type: 'mrkdwn',
+            text: `:warning:* ${data.subject}*`,
+        },
+    });
+    blocks.push({
+        type: 'section',
+        text: {
+            type: 'plain_text',
+            text: data.message + ' → ' + (data.stack || '').split('\n')[0],
+        },
+    });
+    // blocks.push({
+    //     type: "divider"
+    // });
+    // for (const key of Object.keys(blocksData)) {
+    //     blocks.push({
+    //         type: "section",
+    //         text: {
+    //             type: "mrkdwn",
+    //             text: `*${key}*`
+    //         }
+    //     });
+    //     blocks.push({
+    //         type: "section",
+    //         text: {
+    //             type: "plain_text",
+    //             text: (blocksData[key] || "undefined").toString()
+    //         }
+    //     });
+    // }
+    const res = {
+        channel: '#fp-errors',
+        username: 'error-reporter-bot',
+        type: 'mrkdwn',
+        text: data.subject,
+        blocks: blocks,
+    };
+    return res;
+}
+// async function getIpData() {
+//     try {
+//         const ipInfoRequest = await fetch("https://geo.ipify.org/api/v1?apiKey=at_3dMzE1vaZp2Kd8NxMV7HukiFFjutg");
+//         const ipInfo = await ipInfoRequest.json();
+//         logger.log("ipify", ipInfo, ipInfoRequest);
+//         if (ipInfoRequest.ok) {
+//             return {
+//                 ip: ipInfo.ip,
+//                 ...ipInfo.location,
+//             };
+//         } else {
+//             return { ip: ipInfo.messages };
+//         }
+//     } catch (e) {
+//         logger.error(e);
+//         return { ip: e.message };
+//     }
+// }

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

@@ -0,0 +1,2 @@
+export declare function resetGlobalVariables(): void;
+//# sourceMappingURL=reset.d.ts.map

package/dist/esm/tools/reset.js

@@ -0,0 +1,35 @@
+/* eslint-disable prefer-const */
+// @ts-nocheck
+export function resetGlobalVariables() {
+    deleteKey('floorplan');
+    deleteKey('__searchi');
+    deleteKey('__mobxGlobals');
+    deleteKey('__store');
+    deleteKey('__mobxInstanceCount');
+    // Neither of these matches the `__fp` / `__efp` sweep below, so both have to
+    // be named: `__resett` is the kiosk idle-reset timer bound to the plan's UI
+    // (`store/init/init-ui.ts`) and `__expofpReady` is the ready CustomEvent
+    // whose `detail.floorplan` is the instance itself (`load.ts`). Left behind,
+    // each roots its whole dead plan graph from `window`.
+    deleteKey('__resett');
+    deleteKey('__expofpReady');
+    for (let key in window) {
+        if (key === '__efpStyleElements')
+            continue;
+        if (key.includes('__fp') || key.includes('__efp')) {
+            deleteKey(key);
+        }
+    }
+}
+function deleteKey(key) {
+    if (canDelete(key)) {
+        delete window[key];
+    }
+    else {
+        window[key] = undefined;
+    }
+}
+function canDelete(key) {
+    let desc = Object.getOwnPropertyDescriptor(window, key);
+    return desc && desc.configurable;
+}

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

@@ -0,0 +1,7 @@
+interface SentryConfig {
+    eventId?: string;
+    isWebview: boolean;
+}
+export declare function initSentry(options: SentryConfig): void;
+export {};
+//# sourceMappingURL=sentry.d.ts.map

package/dist/esm/tools/sentry.js

@@ -0,0 +1,166 @@
+import { makeOfflineTransport } from '@sentry/core';
+import { captureException, init, makeFetchTransport, setTag, setUser } from '@sentry/react';
+const SENTRY_ENVIRONMENT = process.env.NODE_ENV || 'development';
+const SENTRY_RELEASE = process.env.SENTRY_RELEASE || undefined;
+// Create a store based on localStorage for storing events in offline mode
+function createLocalStorageStore() {
+    const STORAGE_KEY = 'sentry_offline_queue';
+    const MAX_QUEUE_SIZE = 50; // Limit queue size
+    return {
+        async push(envelope) {
+            try {
+                const queue = JSON.parse(localStorage?.getItem(STORAGE_KEY) || '[]');
+                queue.push({ envelope, timestamp: Date.now() });
+                // Limit queue size by removing oldest events
+                if (queue.length > MAX_QUEUE_SIZE) {
+                    queue.shift();
+                }
+                localStorage?.setItem(STORAGE_KEY, JSON.stringify(queue));
+            }
+            catch {
+                // Best-effort: ignore localStorage write/parse failures (quota, private mode).
+            }
+        },
+        async unshift(envelope) {
+            try {
+                const queue = JSON.parse(localStorage?.getItem(STORAGE_KEY) || '[]');
+                queue.unshift({ envelope, timestamp: Date.now() });
+                // Limit queue size
+                if (queue.length > MAX_QUEUE_SIZE) {
+                    queue.pop();
+                }
+                localStorage?.setItem(STORAGE_KEY, JSON.stringify(queue));
+            }
+            catch {
+                // Best-effort: ignore localStorage write/parse failures (quota, private mode).
+            }
+        },
+        async shift() {
+            try {
+                const queue = JSON.parse(localStorage?.getItem(STORAGE_KEY) || '[]');
+                if (queue.length === 0) {
+                    // Clear localStorage if queue is empty
+                    localStorage?.removeItem(STORAGE_KEY);
+                    return;
+                }
+                const item = queue.shift();
+                // Update queue in localStorage
+                if (queue.length === 0) {
+                    // If queue became empty, completely remove the key
+                    localStorage?.removeItem(STORAGE_KEY);
+                }
+                else {
+                    localStorage?.setItem(STORAGE_KEY, JSON.stringify(queue));
+                }
+                return item?.envelope;
+            }
+            catch {
+                return;
+            }
+        },
+    };
+}
+export function initSentry(options) {
+    // Wrap fetch transport in offline transport with localStorage store
+    const createOfflineTransport = makeOfflineTransport(makeFetchTransport);
+    init({
+        dsn: 'https://b2eafc5a038fa2c535099e431de219f2@o4510697102114816.ingest.us.sentry.io/4510697103097856',
+        release: SENTRY_RELEASE,
+        environment: SENTRY_ENVIRONMENT,
+        sendDefaultPii: true,
+        transport: (options) => {
+            return createOfflineTransport({
+                ...options,
+                createStore: () => createLocalStorageStore(),
+                flushAtStartup: true, // Attempt to send queued events on startup
+                shouldStore: async (_envelope, error) => {
+                    // Store events only if offline or network error
+                    if (!navigator.onLine) {
+                        return true;
+                    }
+                    // Store on network errors
+                    if (error &&
+                        (error.message?.includes('Failed to fetch') ||
+                            error.message?.includes('NetworkError') ||
+                            error.message?.includes('Network request failed'))) {
+                        return true;
+                    }
+                    return false;
+                },
+            });
+        },
+        // Performance Monitoring
+        tracesSampleRate: 0.1,
+        ignoreErrors: [
+            /loading chunk \d{1,2}\b/i,
+            /zaloJS/i,
+            /e\.target\.name/i,
+            /ResizeObserver loop/i,
+            /ChunkLoadError/i,
+            /FloorPlan not ready/i,
+            /NetworkError/i,
+            /network error occurred/i,
+            /network request failed/i,
+            /failed to fetch/i,
+            /abort/i,
+        ],
+        beforeSend(event) {
+            if (SENTRY_ENVIRONMENT !== 'production') {
+                return null;
+            }
+            return event;
+        },
+    });
+    if (options.eventId) {
+        setTag('eventId', options.eventId);
+    }
+    setTag('isWebview', options.isWebview);
+    setTag('source', 'main');
+    // Set anonymous user identity so Sentry can count affected users
+    setUser({ ip_address: '{{auto}}' });
+    // Set up global error handlers
+    setupGlobalErrorHandlers();
+}
+function setupGlobalErrorHandlers() {
+    // Handle unhandled promise rejections
+    window.addEventListener('unhandledrejection', (event) => {
+        captureException(event.reason, {
+            contexts: {
+                unhandledRejection: {
+                    promise: event.promise,
+                },
+            },
+        });
+    });
+    // Handle window errors (already handled by Sentry by default, but we can add custom logic)
+    const originalOnError = window.onerror;
+    window.onerror = (message, source, lineno, colno, error) => {
+        if (error) {
+            captureException(error, {
+                contexts: {
+                    windowError: {
+                        message,
+                        source,
+                        lineno,
+                        colno,
+                    },
+                },
+            });
+        }
+        // Call original handler if it exists
+        if (originalOnError) {
+            originalOnError.call(window, message, source, lineno, colno, error);
+        }
+        return false; // Don't prevent default error handling
+    };
+    // Monitor connection restoration for immediate sending of queued events
+    window.addEventListener('online', () => {
+        // Sentry will automatically attempt to send queued events
+        // thanks to flushAtStartup and retry mechanism in offline transport
+        // We can also manually call flush if needed
+        const client = window.__SENTRY__?.hub?.getClient();
+        if (client) {
+            client.flush().catch(() => undefined);
+        }
+    });
+}

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

@@ -0,0 +1,36 @@
+export declare class FpSettings {
+    boothLabelColor: string;
+    boothBorderColor: string;
+    backgroundColor: string;
+    boothBorderWidth?: number;
+    heatmapColors: string[];
+    maxZoom?: number;
+}
+declare class Settings extends FpSettings {
+    EXPO: string;
+    borderless: boolean;
+    wayfinding: boolean;
+    colors: {
+        booths: {
+            default: string;
+            defaultHold: string;
+            defaultSold: string;
+            seectedLight: string | null;
+            selected: string;
+            selectedBorder: null;
+            wayfinding: {
+                selected: string;
+                selectedBorder: null;
+            };
+            empty: string;
+        };
+    };
+}
+/**
+ * The live event's settings. Every property read forwards to the settings of
+ * whichever plan is loaded now, so importers can keep holding this binding
+ * across a plan swap — capturing a field from it at module scope cannot.
+ */
+declare const _default: Settings;
+export default _default;
+//# sourceMappingURL=settings.d.ts.map

package/dist/esm/tools/settings.js

@@ -0,0 +1,110 @@
+// Legacy provider being migrated to @expofp/schema + getConfig() (@expofp/config).
+// Prefer that path for new fields, defaults, and per-expo overrides, and shrink
+// this file when a change makes it cheap — extend it only when the config path
+// can't host the data cleanly yet.
+import { getConfig } from '@expofp/config';
+import deepmerge from 'deepmerge';
+import { getFpSvgJs, getWfData } from '../data/fp-payloads.js';
+import { createSwappableProxy } from '../utils/swappable-proxy.js';
+import { eventScopedValue } from './event-scoped-cache.js';
+// TODO create complex solution to check if color input is valid (color none is fails run time)
+export class FpSettings {
+    constructor() {
+        this.boothLabelColor = '#fff';
+        this.boothBorderColor = '#fff';
+        this.backgroundColor = '#ebebeb';
+        this.heatmapColors = [
+            '#FDE7C7',
+            '#FDDBAE',
+            '#FDC48D',
+            '#FCB37C',
+            '#FCA26D',
+            '#F67B5B',
+            '#EB483E',
+            '#E03143',
+            '#6C0022',
+        ];
+    }
+}
+class Settings extends FpSettings {
+    constructor() {
+        super(...arguments);
+        // this is not replaced with const, so calls to settings.EXPO won't get replaced with const
+        // this is done for template to work
+        // Same value as `window.__efpEvent`, but read from the config the load path
+        // has already installed — the global is only written later, in the loader's
+        // constructor, so reading it here could latch the previous event's id.
+        this.EXPO = getConfig().expo;
+        this.borderless = false;
+        this.wayfinding = false;
+        // borderWidth: 1,
+        this.colors = {
+            // base: "#ebebeb",
+            booths: {
+                default: '#41b6e7',
+                defaultHold: '#48484A',
+                defaultSold: '#41b6e7',
+                seectedLight: null,
+                selected: '#fb3e59',
+                selectedBorder: null,
+                wayfinding: {
+                    selected: '#0088D6',
+                    selectedBorder: null,
+                },
+                empty: '#aaaaaa', // this is #aaa for default BG #d6d6d6d
+            },
+        };
+    }
+}
+/**
+ * Builds the settings object for whichever event is live. Called lazily, once
+ * per plan: the result is a single mutable object (call sites read it as one),
+ * so it is event-scoped state rather than a per-call derivation — hence the
+ * memo rather than the `fp-payloads.ts` read-per-call pattern (ADR-0011).
+ */
+function buildSettings() {
+    let settings = new Settings();
+    if (settings.EXPO.startsWith('sxsw2024')) {
+        settings.colors.booths.selected = '#FF6400';
+        settings.colors.booths.seectedLight = '#808080';
+    }
+    else if (settings.EXPO === 'whxdubai2026') {
+        settings.colors.booths.selected = '#2B66FE';
+        settings.maxZoom = 450;
+    }
+    else if (settings.EXPO === 'whxlabs2026') {
+        settings.colors.booths.selected = '#2B66FE';
+    }
+    else if (settings.EXPO === 'wineparis2026') {
+        settings.maxZoom = 450;
+    }
+    else if (settings.EXPO === 'rdemo2025') {
+        settings.maxZoom = 450;
+    }
+    // else if (settings.EXPO === "eventtechlive2019") {
+    //     settings.borderless = true;
+    // }
+    const globalSettings = window.__settings;
+    const fpSettings = getFpSvgJs().__fpSettings ?? {};
+    settings = deepmerge(settings, globalSettings ?? fpSettings);
+    settings = deepmerge(settings, fpSettings);
+    // Wayfinding availability is a property of the event's data, not of the
+    // drawing module that used to poke it in here as an import side effect.
+    // Assigned after the merges, exactly where the old side effect landed.
+    settings.wayfinding = !getConfig().hideDirections && getWfData() ? true : false;
+    // Config wins over the plan payload: an organizer-set selection color
+    // applies to booths, spaces and outdoor POI pins alike.
+    const configSelectionColor = getConfig().selectionColor;
+    if (configSelectionColor) {
+        settings.colors.booths.selected = configSelectionColor;
+        settings.colors.booths.wayfinding.selected = configSelectionColor;
+    }
+    return settings;
+}
+const liveSettings = eventScopedValue(buildSettings);
+/**
+ * The live event's settings. Every property read forwards to the settings of
+ * whichever plan is loaded now, so importers can keep holding this binding
+ * across a plan swap — capturing a field from it at module scope cannot.
+ */
+export default createSwappableProxy('settings', liveSettings);

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

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

package/dist/esm/tools/slug.js

@@ -0,0 +1,27 @@
+import slugify from 'slugify';
+import { eventScopedValue } from './event-scoped-cache.js';
+// function slugify(text: string) {
+//     return text.toString().toLowerCase()
+//         .replace(/\s+/g, '-')           // Replace spaces with -
+//         .replace(/[^\w\-]+/g, '')       // Remove all non-word chars
+//         .replace(/\-\-+/g, '-')         // Replace multiple - with single -
+//         .replace(/^-+/, '')             // Trim - from start of text
+//         .replace(/-+$/, '');            // Trim - from end of text
+// }
+/**
+ * The slugs handed out for the live event. Uniqueness is per event: carrying
+ * the previous plan's slugs over would make the next event's booths collide
+ * with names nothing on the page has any more, and suffix them (ADR-0011).
+ */
+const generatedSlugs = eventScopedValue(() => new Set());
+export function generateUniqueSlug(text) {
+    const slugs = generatedSlugs();
+    let append = 0;
+    const slugBase = slugify(text, { remove: /[*+~.()'"!:@]/g, lower: true });
+    let slug;
+    do {
+        slug = slugBase + (append++ > 0 || !slugBase ? append : '');
+    } while (slugs.has(slug));
+    slugs.add(slug);
+    return slug;
+}

package/dist/esm/tools/strip-html.d.ts

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

package/dist/esm/tools/strip-html.js

@@ -0,0 +1,7 @@
+export function stripHtml(html) {
+    if (typeof document === 'undefined')
+        return html;
+    const div = document.createElement('div');
+    div.innerHTML = html;
+    return div.textContent ?? '';
+}

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