@expofp/floorplan 0.0.0-experimental.2d6c681

package/dist/esm/tools/gtag.js

@@ -0,0 +1,287 @@
+import data from '../data';
+import { registerPlanDisposer } from '../plan-lifecycle.js';
+import settings from '../tools/settings';
+import trackEvent from '../tools/track-event';
+import isDebug from '../utils/is-debug';
+const ga_common_prop = 'G-78CKLYWFJK';
+window.dataLayer = window.dataLayer || [];
+export default function gtag(...args) {
+    (window.dataLayer ??= []).push(arguments);
+}
+export var GaEventActions;
+(function (GaEventActions) {
+    GaEventActions["Load"] = "Load floor plan";
+    GaEventActions["ViewBooth"] = "View booth";
+    GaEventActions["ViewExhibitor"] = "View exhibitor";
+    GaEventActions["ViewCategory"] = "View category";
+    GaEventActions["Search"] = "Search";
+    GaEventActions["ClickCustomButton"] = "Click custom button";
+    GaEventActions["ViewVideo"] = "View video";
+    GaEventActions["ViewGallery"] = "View gallery";
+    GaEventActions["ClickPhone"] = "Click phone";
+    GaEventActions["ClickEmail"] = "Click email";
+    GaEventActions["ClickWebsite"] = "Click website";
+    GaEventActions["ClickFacebook"] = "Click Facebook";
+    GaEventActions["ClickInstagaram"] = "Click Instagram";
+    GaEventActions["ClickLinkedin"] = "Click Linkedin";
+    GaEventActions["ClickTwitter"] = "Click Twitter";
+    GaEventActions["ClickGooglePlus"] = "Click Google Plus";
+    GaEventActions["ClickXing"] = "Click Xing";
+    GaEventActions["ClickYoutube"] = "Click Youtube";
+    GaEventActions["ClickBookmark"] = "Click bookmark";
+    GaEventActions["ClickDirections"] = "Click Directions";
+    GaEventActions["Rendered"] = "Floor plan rendered";
+    GaEventActions["WsExhibitorClick"] = "ws_exhibitor_click";
+})(GaEventActions || (GaEventActions = {}));
+export async function checkUserIsGDPR() {
+    try {
+        const fetchPromise = fetch(`https://consent.expofp.com/api/verify-ip/is-in-gdpr`);
+        const timeoutPromise = new Promise((resolve) => {
+            setTimeout(() => {
+                resolve(null);
+            }, 5000);
+        });
+        const response = await Promise.race([fetchPromise, timeoutPromise]);
+        if (response instanceof Response && response.ok) {
+            const data = await response.json();
+            return data.result;
+        }
+        return null;
+    }
+    catch (err) {
+        console.error(err);
+        return null;
+    }
+}
+export function hasUserConsent(consent) {
+    if (consent === 'granted' || consent === 'denied')
+        return consent;
+    const consentCookie = document.cookie
+        .split('; ')
+        .find((cookie) => cookie.startsWith('cookie_consent='));
+    if (consentCookie) {
+        const hasCookieConsent = consentCookie === 'cookie_consent=true';
+        return hasCookieConsent ? 'granted' : 'denied';
+    }
+    return undefined;
+}
+export function setCookieConsent(cookieConsent) {
+    const monthInSeconds = 2592000;
+    const domain = isDebug ? 'localhost' : '.expofp.com';
+    // Remove cookie_consent cookie before set
+    document.cookie = `cookie_consent=; expires=Thu, 01 Jan 1970 00:00:00 GMT; path=/; domain=${domain}`;
+    document.cookie = `cookie_consent=; expires=Thu, 01 Jan 1970 00:00:00 GMT; path=/`;
+    document.cookie = cookieConsent
+        ? `cookie_consent=${cookieConsent}; max-age=${monthInSeconds}; domain=${domain}; path=/`
+        : `cookie_consent=${cookieConsent}; max-age=${monthInSeconds}; path=/`;
+}
+function deleteGaCookies() {
+    const cookies = document.cookie.split(';');
+    const domain = isDebug ? 'localhost' : '.expofp.com';
+    for (let i = 0; i < cookies.length; i++) {
+        const cookie = cookies[i];
+        const eqPos = cookie.indexOf('=');
+        const name = eqPos > -1 ? cookie.substr(0, eqPos).trim() : cookie.trim();
+        if (name.startsWith('_ga')) {
+            document.cookie = `${name}=;expires=Thu, 01 Jan 1970 00:00:00 GMT; path=/; domain=${domain}`;
+        }
+    }
+}
+export function setConsentSettings(consent) {
+    let userChoice = hasUserConsent(consent);
+    if (userChoice) {
+        if (userChoice === 'denied') {
+            deleteGaCookies();
+            if (data.gtag) {
+                window[`ga-disable-${data.gtag}`] = true;
+            }
+            window[`ga-disable-${ga_common_prop}`] = true;
+        }
+        else {
+            if (data.gtag) {
+                window[`ga-disable-${data.gtag}`] = false;
+            }
+            window[`ga-disable-${ga_common_prop}`] = false;
+        }
+        gtag('consent', 'update', {
+            analytics_storage: userChoice,
+            ad_personalization: userChoice,
+        });
+    }
+}
+export function sendEventToGa(action, label, eventCategory) {
+    //for reference https://developers.google.com/analytics/devguides/collection/ga4/reference/events
+    switch (action) {
+        case GaEventActions.ViewBooth: {
+            gtag('event', 'select_content', {
+                content_type: action,
+                content_id: label,
+            });
+            trackEvent('booview', label);
+            break;
+        }
+        case GaEventActions.ViewCategory: {
+            gtag('event', 'select_content', {
+                content_type: action,
+                content_id: label,
+            });
+            trackEvent('catview', label);
+            break;
+        }
+        case GaEventActions.ViewExhibitor:
+        case GaEventActions.ViewGallery:
+        case GaEventActions.ViewVideo:
+            gtag('event', 'select_content', {
+                content_type: action,
+                content_id: label,
+            });
+            break;
+        case GaEventActions.Search:
+            gtag('event', 'search', {
+                search_term: label,
+            });
+            trackEvent('search', label);
+            break;
+        case GaEventActions.ClickCustomButton:
+        case GaEventActions.ClickPhone:
+        case GaEventActions.ClickEmail:
+        case GaEventActions.ClickWebsite:
+        case GaEventActions.ClickFacebook:
+        case GaEventActions.ClickInstagaram:
+        case GaEventActions.ClickLinkedin:
+        case GaEventActions.ClickTwitter:
+        case GaEventActions.ClickGooglePlus:
+        case GaEventActions.ClickXing:
+        case GaEventActions.ClickYoutube:
+            gtag('event', 'share', {
+                //method: action,
+                content_type: action,
+                content_id: label,
+            });
+            trackEvent('share', label);
+            break;
+        case GaEventActions.ClickBookmark:
+            // A bookmark click reports itself through its own `bookmark` stat, so it
+            // must NOT also raise `share` the way the other custom buttons do —
+            // counting one click twice is exactly what that event was added to stop.
+            // The GA payload stays byte-identical to ClickCustomButton on purpose:
+            // only the SDK-side duplicate is dropped here. Giving GA the more
+            // precise `content_type` is a separate, customer-visible change.
+            gtag('event', 'share', {
+                content_type: GaEventActions.ClickCustomButton,
+                content_id: label,
+            });
+            break;
+        case GaEventActions.ClickDirections:
+            gtag('event', 'route', {
+                content_type: action,
+                content_id: label,
+            });
+            trackEvent('route', label);
+            break;
+        default:
+            gtag('event', action, {
+                content_type: eventCategory,
+                content_id: label,
+            });
+    }
+}
+export function sendPayloadToGa(action, payload) {
+    gtag('event', action, { ...payload, fp_key: settings.EXPO });
+}
+export function trackWsExhibitorClick(payload) {
+    sendPayloadToGa(GaEventActions.WsExhibitorClick, {
+        exhibitor_id: payload.id,
+        exhibitor_name: payload.name,
+        exhibitor_external_id: payload.externalId,
+        creative_slot: 'ws_slider',
+    });
+    trackEvent('ws_exhibitor_click', payload.id);
+}
+window.gtag = gtag;
+/** Adds the gtag loader for one GA property ahead of the page's first script. */
+function insertGtagScript(property) {
+    const script = document.createElement('script');
+    script.type = 'text/javascript';
+    script.async = true;
+    script.src = `https://www.googletagmanager.com/gtag/js?id=${property}`;
+    const first = document.getElementsByTagName('script')[0];
+    if (first?.parentNode) {
+        first.parentNode.insertBefore(script, first);
+    }
+    else {
+        document.head.appendChild(script);
+    }
+    return script;
+}
+// The loader for our own property, which every plan reports into. Page-level
+// like the `dataLayer` it feeds: `ga_common_prop` is a constant, so re-inserting
+// the tag per plan would re-fetch and re-execute the same googletagmanager
+// bundle on every swap. Survives destroy, as `window.gtag` and `window.dataLayer`
+// already do — `resetGlobalVariables()` leaves all three alone.
+let commonScript;
+/**
+ * Wires GA up for the plan being loaded: the event's own GA property and the
+ * `fp_key` every event is tagged with are the live event's, so this runs once
+ * per plan rather than once per page — module scope would leave the second
+ * event reporting into the first one's property (ADR-0011). The event's tag
+ * comes off again with the plan.
+ */
+export function initGtag() {
+    if (!commonScript) {
+        commonScript = insertGtagScript(ga_common_prop);
+        gtag('js', new Date());
+    }
+    if (data.gtag) {
+        const eventScript = insertGtagScript(data.gtag);
+        gtag('config', data.gtag, { fp_key: settings.EXPO });
+        registerPlanDisposer(() => eventScript.remove());
+    }
+    gtag('config', ga_common_prop, { fp_key: settings.EXPO });
+}
+gtag('consent', 'default', {
+    ad_storage: 'denied',
+    analytics_storage: 'denied',
+    region: [
+        'BE',
+        'BG',
+        'CZ',
+        'DK',
+        'DE',
+        'EE',
+        'IE',
+        'EL',
+        'ES',
+        'FR',
+        'HR',
+        'IT',
+        'CY',
+        'LV',
+        'LT',
+        'LU',
+        'HU',
+        'MT',
+        'NL',
+        'AT',
+        'PL',
+        'PT',
+        'RO',
+        'SI',
+        'SK',
+        'FI',
+        'SE',
+        'UK',
+        'IS',
+        'NO',
+        'LI',
+        'CH',
+        'MK',
+        'AL',
+        'RS',
+        'TR',
+    ],
+    functionality_storage: 'denied',
+    personalization_storage: 'denied',
+    security_storage: 'denied',
+    ad_personalization: 'denied',
+});

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

@@ -0,0 +1,19 @@
+/**
+ * The `?debug=1` / `?debug=0` seed (also the double-encoded `?debug%3D1`
+ * form): persist the choice under the schema-typed `efp-debugMode` key, scrub
+ * the param, reload.
+ *
+ * The reload stays ON PURPOSE (retirement plan §4.5 allows either outcome —
+ * hoisting the seed before `loadConfig` was investigated and rejected):
+ *  - the seed runs inside the `!ignoreQuery`-gated custom-command chain, and
+ *    `ignoreQuery` is only known once `loadConfig` has merged the layers — a
+ *    pre-config seed would fire (and scrub the host page URL) for embeds that
+ *    isolate themselves from the query;
+ *  - the debug UI itself hangs off the boot-time `is-debug` constant
+ *    (Layout renders the panel from it), so without a reload the seeding load
+ *    would not show the panel — the one user-visible point of `?debug=1`;
+ *  - the runtime path (`FloorPlan.applyParameters('debug=1')`) needs the
+ *    reload regardless: the effective config is frozen mid-session.
+ */
+export declare function handleDebugMode(): void;
+//# sourceMappingURL=handleDebugMode.d.ts.map

package/dist/esm/tools/handleDebugMode.js

@@ -0,0 +1,61 @@
+import { DEBUG_KEY, DEBUG_STORAGE_KEY } from '../constants';
+import { replaceQuery } from '../services/url-sync';
+/**
+ * The `?debug=1` / `?debug=0` seed (also the double-encoded `?debug%3D1`
+ * form): persist the choice under the schema-typed `efp-debugMode` key, scrub
+ * the param, reload.
+ *
+ * The reload stays ON PURPOSE (retirement plan §4.5 allows either outcome —
+ * hoisting the seed before `loadConfig` was investigated and rejected):
+ *  - the seed runs inside the `!ignoreQuery`-gated custom-command chain, and
+ *    `ignoreQuery` is only known once `loadConfig` has merged the layers — a
+ *    pre-config seed would fire (and scrub the host page URL) for embeds that
+ *    isolate themselves from the query;
+ *  - the debug UI itself hangs off the boot-time `is-debug` constant
+ *    (Layout renders the panel from it), so without a reload the seeding load
+ *    would not show the panel — the one user-visible point of `?debug=1`;
+ *  - the runtime path (`FloorPlan.applyParameters('debug=1')`) needs the
+ *    reload regardless: the effective config is frozen mid-session.
+ */
+export function handleDebugMode() {
+    try {
+        const url = new URL(window.location.href);
+        let debugValue = null;
+        let paramToDelete = null;
+        for (const [key, value] of url.searchParams) {
+            if (key === DEBUG_KEY) {
+                // ?debug=1
+                debugValue = value;
+                paramToDelete = key;
+                break;
+            }
+            else if (key.startsWith(DEBUG_KEY + '%3D') || key.startsWith(DEBUG_KEY + '=')) {
+                // ?debug%3D1
+                debugValue = key.split('=')[1];
+                paramToDelete = key;
+                break;
+            }
+        }
+        if (debugValue === '1') {
+            localStorage.setItem(DEBUG_STORAGE_KEY, 'true');
+        }
+        else if (debugValue === '0') {
+            localStorage.setItem(DEBUG_STORAGE_KEY, 'false');
+        }
+        else {
+            return;
+        }
+        if (paramToDelete) {
+            url.searchParams.delete(paramToDelete);
+            // under frozen URL writes (offHistory embeds, heatmap mode) the scrub
+            // cannot happen — reloading would replay `?debug=` in an endless loop,
+            // so skip it; the persisted flag shows the panel on the next natural load
+            if (replaceQuery(url.search)) {
+                window.location.reload();
+            }
+        }
+    }
+    catch (err) {
+        console.error('Error in handleDebugMode:', err);
+    }
+}

package/dist/esm/tools/has-html-tags.d.ts

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

package/dist/esm/tools/has-html-tags.js

@@ -0,0 +1,3 @@
+export function hasHtmlTags(text) {
+    return /<[^>]*>/.test(text);
+}

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

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

package/dist/esm/tools/id.js

@@ -0,0 +1,5 @@
+// @ts-nocheck
+let seq = 1000000;
+export function getNextId() {
+    return ++seq;
+}

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

@@ -0,0 +1,5 @@
+export declare function loadJson<T>(url: string): Promise<T>;
+export declare function loadCss(url: string, appendTo: Element | ShadowRoot): void;
+export declare function loadFont(family: string, url: string, d?: any): Promise<any>;
+export declare function loadCustomFonts(customCss: string): Promise<PromiseSettledResult<any>[] | undefined>;
+//# sourceMappingURL=loaders.d.ts.map

package/dist/esm/tools/loaders.js

@@ -0,0 +1,67 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+// @ts-nocheck
+import FontFaceObserver from 'fontfaceobserver';
+import { FONT_FACE } from '../constants';
+import browser from '../utils/browser';
+// function goodUrl(url: string) {
+//     if (url.indexOf("://") === -1) {
+//         return baseRuntimeUrl + url;
+//     }
+//     return url;
+// }
+export async function loadJson(url) {
+    const response = await fetch(url, { credentials: 'same-origin' });
+    return (await response.json());
+}
+export function loadCss(url, appendTo) {
+    const link = document.createElement('link');
+    link.rel = 'stylesheet';
+    link.href = url;
+    link.setAttribute('fetchpriority', 'high');
+    appendTo.appendChild(link);
+}
+export async function loadFont(family, url, d) {
+    d = { style: 'normal', weight: 'normal', ...(d || {}) };
+    const src = `url("${url}")`;
+    if (!window['FontFace']) {
+        if (!family.startsWith('Font Awesome')) {
+            injectFontFace(family, src, d);
+        }
+        return Promise.resolve();
+    }
+    if (family.indexOf(' ') !== -1 && browser.getEngine()?.name === 'Gecko') {
+        family = `'${family}'`;
+    }
+    // this is primarily for ios12, it throws error when family is not correctly formatted
+    let ff;
+    try {
+        ff = new FontFace(family, src, d);
+    }
+    catch {
+        ff = new FontFace(`'${family}'`, src, d);
+    }
+    const documentFonts = document['fonts'];
+    documentFonts.add(ff);
+    return ff.load();
+}
+function injectFontFace(fontFamily, src, d) {
+    const newStyle = document.createElement('style');
+    newStyle.appendChild(document.createTextNode(`@font-face { font-family: ${fontFamily}; font-weight: ${d.weight}; font-style: ${d.style}; src: ${src} format('woff2'); font-display: swap; }`));
+    document.head.appendChild(newStyle);
+    const div = document.createElement('div');
+    div.setAttribute('style', `font-family: oswald; font-weight: ${d.weight}; position: fixed; left: -1000px; top: 0; visibility: hidden`);
+    div.innerHTML = 'Oswald';
+    document.body.appendChild(div);
+}
+export async function loadCustomFonts(customCss) {
+    const fontFaceRaw = getComputedStyle(document.documentElement).getPropertyValue(FONT_FACE) ||
+        customCss.match(/--expofp-font-face:\s*([^;]*)/)?.[1];
+    if (!fontFaceRaw)
+        return;
+    const fontFaces = fontFaceRaw
+        .replace(/"/g, '')
+        .split(', ')
+        .map((x) => x.trim());
+    const fontObservers = fontFaces.map((fontFace) => new FontFaceObserver(fontFace).load());
+    return Promise.allSettled(fontObservers);
+}

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

@@ -0,0 +1,38 @@
+/**
+ * @deprecated Logger will be removed in future.
+ * Use debug package instead, e.g. `debug('efp:router')("Initialized")`,
+ * or `const logger = debug('efp:router'); logger("Initialized")`
+ */
+declare class Logger {
+    /**
+     * @deprecated Logger will be removed in future
+     */
+    readonly messages: string[];
+    /**
+     * @deprecated Logger will be removed in future.
+     * Use debug package instead, e.g. `debug('efp:router')("Initialized")`,
+     * or `const logger = debug('efp:router'); logger("Initialized")`
+     */
+    log(...args: any[]): void;
+    /**
+     * @deprecated Use explicit console.error instead
+     */
+    error(...args: any[]): void;
+    /**
+     * @deprecated Use explicit console.warn instead
+     */
+    warn(...args: any[]): void;
+    /**
+     * @deprecated Use explicit console.info instead
+     */
+    info(...args: any[]): void;
+    private push;
+}
+/**
+ * @deprecated Logger will be removed in future.
+ * Use debug package instead, e.g. `debug('efp:router')("Initialized")`,
+ * or `const logger = debug('efp:router'); logger("Initialized")`
+ */
+declare const _default: Logger;
+export default _default;
+//# sourceMappingURL=logger.d.ts.map

package/dist/esm/tools/logger.js

@@ -0,0 +1,87 @@
+/* eslint-disable @typescript-eslint/no-explicit-any, no-empty */
+// @ts-nocheck
+import debug from 'debug';
+/**
+ * @deprecated Logger will be removed in future.
+ * Use debug package instead, e.g. `debug('efp:router')("Initialized")`,
+ * or `const logger = debug('efp:router'); logger("Initialized")`
+ */
+class Logger {
+    constructor() {
+        /**
+         * @deprecated Logger will be removed in future
+         */
+        this.messages = [];
+    }
+    /**
+     * @deprecated Logger will be removed in future.
+     * Use debug package instead, e.g. `debug('efp:router')("Initialized")`,
+     * or `const logger = debug('efp:router'); logger("Initialized")`
+     */
+    log(...args) {
+        this.push('DEBUG', args);
+        debug('efp:floorplan:debug')(...args);
+        // if (!isDebug) return;
+        // callLogFunc(console.log, args);
+    }
+    /**
+     * @deprecated Use explicit console.error instead
+     */
+    error(...args) {
+        this.push('ERROR', args);
+        callLogFunc(console.error, args);
+    }
+    /**
+     * @deprecated Use explicit console.warn instead
+     */
+    warn(...args) {
+        this.push('WARN', args);
+        callLogFunc(console.warn, args);
+    }
+    /**
+     * @deprecated Use explicit console.info instead
+     */
+    info(...args) {
+        this.push('INFO', args);
+        debug('efp:floorplan:info')(...args);
+        // callLogFunc(console.info, args);
+    }
+    push(level, args) {
+        const argsMapped = args.map((x) => {
+            if (typeof x === 'object')
+                try {
+                    return JSON.stringify(x);
+                }
+                catch (e) {
+                    return e.message;
+                }
+            return x;
+        });
+        const message = level + '\t' + new Date().toISOString() + '\t' + argsMapped.join('; ');
+        this.messages.push(message);
+        const max = 1000;
+        if (this.messages.length > max) {
+            this.messages.splice(0, max / 2);
+        }
+    }
+}
+// fix for IE11
+function callLogFunc(func, args) {
+    try {
+        func.apply(func, args);
+    }
+    catch (e) { }
+}
+/**
+ * @deprecated Logger will be removed in future.
+ * Use debug package instead, e.g. `debug('efp:router')("Initialized")`,
+ * or `const logger = debug('efp:router'); logger("Initialized")`
+ */
+export default new Logger();
+// //
+// declare global {
+//     const __logger: typeof logger1;
+// }
+// extendGlobal({
+//     __logger: logger1,
+// });

package/dist/esm/tools/rebooking-config.d.ts

@@ -0,0 +1,10 @@
+import { RebookingState } from '../store/ExhibitorStore';
+export interface RebookingStateConfig {
+    iconName: string;
+    color: {
+        primary: string;
+        secondary: string;
+    };
+}
+export declare const rebookingStateConfig: Record<RebookingState, RebookingStateConfig>;
+//# sourceMappingURL=rebooking-config.d.ts.map

package/dist/esm/tools/rebooking-config.js

@@ -0,0 +1,19 @@
+import { RebookingState } from '../store/ExhibitorStore';
+export const rebookingStateConfig = {
+    [RebookingState.Unasked]: {
+        iconName: 'icon-question-mark',
+        color: { primary: '#8E99AB', secondary: '#EAEFF9' },
+    },
+    [RebookingState.Accepted]: {
+        iconName: 'icon-checkmark',
+        color: { primary: '#32B175', secondary: '#E4FFF2' },
+    },
+    [RebookingState.Rejected]: {
+        iconName: 'icon-close',
+        color: { primary: '#E1463C', secondary: '#FFEDEB' },
+    },
+    [RebookingState.Undecided]: {
+        iconName: 'icon-switch-horizontal',
+        color: { primary: '#FABA27', secondary: '#FFF7E5' },
+    },
+};

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

@@ -0,0 +1,11 @@
+declare const TOKEN_KEY = "rt";
+export declare function getRebookingTokenFromQuery(): string | null;
+export declare function getRebookingToken(): string | null;
+export declare function retainRebookingToken(token: string): void;
+export interface RebookingParams {
+    [TOKEN_KEY]: string;
+    expoKey: string;
+}
+export declare function buildRebookingUrl(path: string, params: RebookingParams): string;
+export {};
+//# sourceMappingURL=rebookingUrl.d.ts.map

package/dist/esm/tools/rebookingUrl.js

@@ -0,0 +1,27 @@
+import { safeDecode } from '@expofp/utils';
+const TOKEN_KEY = 'rt';
+// `?rt=` — the rebooking auth token: a request credential riding the URL, not config or
+// selection state, so it stays a direct read (retirement plan §4.11, same family as the
+// heatmap `t` token). The pre-decode tolerates double-encoded links; keep it (but
+// tolerantly — this runs on the boot custom-command chain, where a malformed
+// percent-escape in the query must not throw).
+export function getRebookingTokenFromQuery() {
+    return new URLSearchParams(safeDecode(window.location.search)).get(TOKEN_KEY);
+}
+export function getRebookingToken() {
+    let token = getRebookingTokenFromQuery();
+    if (!token) {
+        token = sessionStorage.getItem(TOKEN_KEY);
+    }
+    return token;
+}
+export function retainRebookingToken(token) {
+    sessionStorage.setItem(TOKEN_KEY, token);
+}
+export function buildRebookingUrl(path, params) {
+    const url = new URL(path, 'https://app.expofp.com/');
+    for (const [key, value] of Object.entries(params)) {
+        url.searchParams.set(key, value);
+    }
+    return url.href;
+}

package/dist/esm/tools/report-error.d.ts

@@ -0,0 +1,2 @@
+export default function reportError(e: Partial<ErrorEvent>): void;
+//# sourceMappingURL=report-error.d.ts.map