@expofp/floorplan 0.0.0-experimental.cf063fc

package/dist/esm/store/RootStore.js

@@ -0,0 +1,666 @@
+import { __decorate } from "tslib";
+/* eslint-disable @typescript-eslint/no-explicit-any, @typescript-eslint/consistent-type-imports, @typescript-eslint/no-inferrable-types, import/no-duplicates, no-var, prefer-const */
+// @ts-nocheck
+import { action, computed, observable, runInAction } from 'mobx';
+import { LANGUAGE_TYPE } from '../constants';
+import { URLFilterManager } from '../services/URLFilterManager';
+import { GaEventActions, sendEventToGa } from '../tools/gtag';
+import logger from '../tools/logger';
+import { isWebGlSupported } from '../utils';
+import { resetLocale } from '../utils/i18n';
+import isMobile from '../utils/is-mobile';
+import isWebview from '../utils/is-webview';
+import { sanitizeSearch } from '../utils/sanitizeText';
+import BookmarksStore from './BookmarksStore';
+import BoothStore, { BoothBase, RegularBooth } from './BoothStore';
+import CategoryFilterStore from './CategoryFilterStore';
+import CategoryStore, { Category } from './CategoryStore';
+import EventStore, { EventItem } from './EventStore';
+import ExhibitorStore, { Exhibitor } from './ExhibitorStore';
+import FuzzySearchEngineStore from './FuzzySearchEngineStore';
+import HeatmapStore from './HeatmapStore';
+import IntercomStore from './IntercomStore';
+import LayerStore, { LayersMode } from './LayerStore';
+import MaplibreStore from './MaplibreStore';
+import OverlayStore from './OverlayStore';
+import PoiMarkerStore from './PoiMarkerStore';
+import PoiTypeStore from './PoiTypeStore';
+import { SearchShortcutProvider } from './providers/SearchShortcutProvider';
+import { SessionsShortcutProvider } from './providers/SessionsShortcutProvider';
+import { SpeakerShortcutProvider } from './providers/SpeakerShortcutProvider';
+import RoutePlannerStore from './RoutePlannerStore';
+import RouteStore from './RouteStore';
+import SearchButtonsStore from './SearchButtonsStore';
+import SearchStore from './SearchStore';
+import SessionsFilterStore from './SessionsFilterStore';
+import { ShortcutRegistry } from './ShortcutRegistry';
+import SpeakerFilterStore from './SpeakerFilterStore';
+import SpeakerStore from './SpeakerStore';
+import { SpeakerItem } from './SpeakerStore';
+import ToursStore from './ToursStore';
+import UIState from './UIState';
+import { focusVenueForBooths } from './venue-selection';
+import VenueStore from './VenueStore';
+export default class RootStore {
+    setResetCameraFn(resetCameraFn) {
+        this.resetCameraFn = resetCameraFn;
+    }
+    constructor() {
+        this.selectionCameraRequest = 0;
+        this.initialized = false;
+        // this.fp = fp;
+        this.categoryStore = new CategoryStore(this);
+        this.exhibitorStore = new ExhibitorStore(this);
+        this.boothStore = new BoothStore(this);
+        this.routeStore = new RouteStore(this);
+        this.routePlannerStore = new RoutePlannerStore(this);
+        this.toursStore = new ToursStore(this);
+        this.uiState = new UIState(this);
+        this.overlayStore = new OverlayStore(this);
+        this.maplibreStore = new MaplibreStore(this);
+        this.layerStore = new LayerStore(this);
+        this.venueStore = new VenueStore(this);
+        this.intercomStore = new IntercomStore();
+        this.eventStore = new EventStore(this);
+        this.heatmapStore = new HeatmapStore();
+        this.poiTypeStore = new PoiTypeStore(this);
+        this.poiMarkerStore = new PoiMarkerStore(this);
+        this.fuzzySearchEngineStore = new FuzzySearchEngineStore([
+            'name',
+            'title',
+            'fullName',
+            'booths.name',
+        ]);
+        this.categoryFilterStore = new CategoryFilterStore(this);
+        this.sessionsFilterStore = new SessionsFilterStore(this);
+        this.speakerStore = new SpeakerStore(this);
+        this.speakerFilterStore = new SpeakerFilterStore(this);
+        this.searchStore = new SearchStore(this);
+        this.searchButtonsStore = new SearchButtonsStore(this);
+        this.bookmarksStore = new BookmarksStore(this);
+        this.urlFilterManager = new URLFilterManager(this);
+        this.shortcutRegistry = new ShortcutRegistry();
+        this.registerShortcutProviders();
+    }
+    /**
+     * Defers a selection's camera move past the overlay animation (longer on
+     * webview/mobile, where the overlay animates slower), and lets a pending
+     * venue entry land first so the camera flies to an already-focused venue.
+     * `resolveItems` runs at fire time: the addressed booth may only exist once
+     * the delay has elapsed, and returning `null` cancels the move.
+     */
+    scheduleSelectionCamera(cameraRequest, venueReady, resolveItems) {
+        setTimeout(() => {
+            const items = resolveItems();
+            if (!items)
+                return;
+            if (venueReady)
+                void venueReady.then(() => this.moveToList(items, true, cameraRequest));
+            else
+                this.moveToList(items, false, cameraRequest);
+        }, isWebview || isMobile ? 500 : 50);
+    }
+    selectExhibitor(exhibitor, focus = true) {
+        const cameraRequest = ++this.selectionCameraRequest;
+        // if (data.hideCompanies) return;
+        this.uiState.hoveredExhibitor = null;
+        this.uiState.details = exhibitor;
+        var visible = exhibitor.booths.filter((b) => b.visible);
+        var invisible = exhibitor.booths.filter((b) => !b.visible);
+        let venueReady;
+        if (!visible.length && invisible.length) {
+            if (this.venueStore.hasVenueModel) {
+                // Venue model: focus + level state only; the booth camera reaction
+                // owns the fly (KTD-7/KTD-8).
+                venueReady = focusVenueForBooths(this.venueStore, [invisible[0]]);
+            }
+            else {
+                this.layerStore.updateVisibility(invisible[0].layer, true);
+            }
+        }
+        if (!focus)
+            return;
+        const destinationLayerName = invisible[0]?.layer?.name;
+        const cameraBooths = visible.length
+            ? visible
+            : invisible.filter((booth) => booth.layer?.name === destinationLayerName);
+        this.scheduleSelectionCamera(cameraRequest, venueReady, () => cameraBooths);
+    }
+    selectBooth(booth, focus = true) {
+        const cameraRequest = ++this.selectionCameraRequest;
+        let b = Array.isArray(booth) ? booth : [booth];
+        this.uiState.details = b[0];
+        if (b.length === 1 && b[0].schedule?.length) {
+            this.uiState.desiredOverlaySize = 'medium';
+        }
+        let venueReady;
+        if (b.length === 1 && b[0].layer && !b[0].visible) {
+            if (this.venueStore.hasVenueModel) {
+                // Venue model: focus + level state only; the booth camera reaction
+                // owns the fly (KTD-7/KTD-8).
+                venueReady = focusVenueForBooths(this.venueStore, b);
+            }
+            else if (this.layerStore.mode === LayersMode.Radio) {
+                this.layerStore.updateVisibility(b[0].layer, true);
+            }
+        }
+        if (focus)
+            this.scheduleSelectionCamera(cameraRequest, venueReady, () => b);
+    }
+    reset() {
+        const el = window['__searchi'];
+        if (el &&
+            el.querySelector &&
+            el.querySelector('input[type=search]') &&
+            el.querySelector('input[type=search]').blur) {
+            el.querySelector('input[type=search]').blur();
+        }
+        window.setTimeout(() => {
+            if (this.uiState.setKioskModeEnabled) {
+                return;
+            }
+            resetLocale().then(() => {
+                runInAction(() => {
+                    this.selectSearch('');
+                    this.uiState.details = null;
+                    this.resetCameraFn?.();
+                    this.uiState.menu = false;
+                    this.searchStore.resetSearchBox();
+                    this.searchButtonsStore.clearAllFilters();
+                });
+                setTimeout(() => {
+                    runInAction(() => {
+                        this.uiState.inIdle = true;
+                    });
+                }, 100);
+            });
+        }, 1000);
+    }
+    selectNone() {
+        if (window['__resett'])
+            window['__resett']();
+        this.uiState.details = this.uiState.selectedCategory;
+    }
+    selectBookmarks() {
+        this.uiState.details = null;
+        this.uiState.list = { type: 'bookmarks' };
+    }
+    selectVisited() {
+        this.uiState.details = null;
+        this.uiState.list = { type: 'visited' };
+    }
+    selectLanguage() {
+        this.uiState.details = null;
+        this.uiState.list = { type: LANGUAGE_TYPE };
+    }
+    selectCategory(category) {
+        if (window['__resett'])
+            window['__resett']();
+        this.uiState.details = category;
+        this.uiState.list = { type: 'category', category };
+        this.uiState.desiredOverlaySize = 'full';
+        const visible = category.exhibitors.find((e) => e.booths.find((b) => b.visible));
+        if (!visible)
+            this.layerStore.updateVisibility(category.exhibitors[0]?.booths[0]?.layer, true);
+        setTimeout(() => {
+            this.uiState.moveToBooths = category.exhibitors
+                .filter((e) => e.booths.find((b) => b.visible))
+                .flatMap((e) => e.booths);
+        }, 200);
+    }
+    selectEventItem(eventItem, focus = true) {
+        const cameraRequest = ++this.selectionCameraRequest;
+        this.uiState.hoveredExhibitor = null;
+        this.uiState.details = eventItem;
+        this.uiState.desiredOverlaySize = 'medium';
+        let venueReady;
+        if (eventItem.boothId) {
+            const booth = this.boothStore.booths.find((b) => b.id === eventItem.boothId);
+            if (booth?.layer && !booth.visible) {
+                if (this.venueStore.hasVenueModel) {
+                    venueReady = focusVenueForBooths(this.venueStore, [booth]);
+                }
+                else if (this.layerStore.mode === LayersMode.Radio) {
+                    this.layerStore.updateVisibility(booth.layer, true);
+                }
+            }
+        }
+        if (focus) {
+            this.scheduleSelectionCamera(cameraRequest, venueReady, () => {
+                if (!eventItem.boothId)
+                    return null;
+                const booth = this.boothStore.booths.find((b) => b.id === eventItem.boothId);
+                return booth ? [booth] : null;
+            });
+        }
+    }
+    selectSearch(text) {
+        if (window['__resett'])
+            window['__resett']();
+        this.uiState.details = null;
+        this.speakerStore.clearSelectedSpeaker();
+        this.uiState.list = {
+            type: 'search',
+            text: sanitizeSearch(text, Object.keys(this.uiState.mapSettings).map((k) => `${k}=`)),
+            focused: false,
+        };
+        this.uiState.activeListIndex = -1;
+    }
+    clickBookmarks() {
+        if (window['__resett'])
+            window['__resett']();
+        this.uiState.menu = false;
+        this.selectBookmarks();
+        this.moveToList();
+        this.showMap();
+    }
+    clickVisited() {
+        if (window['__resett'])
+            window['__resett']();
+        this.uiState.menu = false;
+        this.selectVisited();
+        this.moveToList();
+        this.showMap();
+    }
+    clickLanguage() {
+        if (window['__resett'])
+            window['__resett']();
+        this.uiState.menu = false;
+        this.selectLanguage();
+    }
+    clickCategory(category) {
+        if (window['__resett'])
+            window['__resett']();
+        this.uiState.menu = false;
+        this.selectCategory(category);
+        if (this.uiState.onCategoryClick)
+            this.uiState.onCategoryClick({
+                id: category.id,
+                name: category.name,
+                exhibitors: category.exhibitors.map((e) => e.id),
+            });
+        setTimeout(() => {
+            this.moveToList();
+            this.showMap();
+        }, 100);
+    }
+    clickSeminars() {
+        this.clickCategory(this.categoryStore.seminarsCategory);
+    }
+    clickBoothInList(booth) {
+        if (window['__resett'])
+            window['__resett']();
+        this.uiState.hoveredBooth = null;
+        this.selectBooth(booth);
+        this.moveToList([booth]);
+        this.showMap();
+    }
+    clickBoothInList2(booth) {
+        if (window['__resett'])
+            window['__resett']();
+        this.uiState.hoveredBooth = null;
+        this.selectBooth(booth, false);
+        window.setTimeout(() => {
+            this.moveToList([booth]);
+            this.showMap();
+        }, navigator.userAgent.toLowerCase().indexOf('android') > -1 ? 400 : 50);
+    }
+    clickBooth(booth) {
+        // Captured before the `selectSearch()` calls below, which clear `details`
+        // in every list mode they handle. The tracking branches ask whether THIS
+        // click changes the selection, and by the time they run the answer has
+        // already been erased — so in those modes the view went unreported.
+        const previousDetails = this.uiState.details;
+        this.uiState.menu = false;
+        if (this.uiState.list.type === 'sessions') {
+            this.searchStore.selectSearch();
+        }
+        if (this.uiState.list.type === 'speakers') {
+            this.searchStore.selectSearch();
+        }
+        if (this.uiState.list.type === 'tours') {
+            this.searchStore.selectSearch();
+        }
+        if (this.uiState.list.type === 'multi-point-tour') {
+            this.searchStore.selectSearch();
+        }
+        if (this.uiState.selectedRoute?.from && this.uiState.selectedRoute?.to)
+            return;
+        if (this.uiState.selectedRoute?.to && !this.uiState.selectedRoute?.from && booth) {
+            this.routeStore.setStartPoint(booth);
+            return;
+        }
+        if (!booth) {
+            this.uiState.details = null;
+            this.fp.hidePathways();
+            this.uiState.list = { type: 'search', text: '', focused: false };
+            if (this.uiState.onBoothClick)
+                this.uiState.onBoothClick({ target: null });
+            return;
+        }
+        else
+            this.routeStore.tempToBooth = booth;
+        if (this.uiState.onBoothClick) {
+            const layer = {
+                name: '',
+                description: '',
+            };
+            const e = {
+                target: { ...booth, layer: booth.layer || layer },
+            };
+            this.uiState.onBoothClick(e);
+        }
+        if (booth.exhibitors.length === 1 && booth instanceof RegularBooth) {
+            // We need to select an exhibitor and track the booth click. The parked
+            // event names the exhibitor it stands in for, so a stale entry can never
+            // be spent on an unrelated selection.
+            const exhibitor = booth.exhibitors[0];
+            if (previousDetails === exhibitor) {
+                // That exhibitor's card was already open, so `selectedExhibitor` will
+                // not change and the reaction that spends `forceTrack` will never run.
+                // Report here instead — clicking a second booth of the same exhibitor,
+                // or re-clicking this one, is still a view of THIS booth.
+                sendEventToGa(GaEventActions.ViewBooth, booth.name);
+            }
+            else {
+                this.heatmapStore.forceTrack = {
+                    action: GaEventActions.ViewBooth,
+                    label: booth.name,
+                    exhibitor,
+                };
+            }
+            this.selectExhibitor(exhibitor, false);
+        }
+        else {
+            // Same no-op selection, same dropped view: re-clicking a booth whose own
+            // card is already open leaves `selectedBooth` unchanged, so the reaction
+            // in Layout never runs. Measured like the single-exhibitor case above.
+            if (previousDetails === booth)
+                sendEventToGa(GaEventActions.ViewBooth, booth.name);
+            this.selectBooth(booth, false);
+        }
+        this.showMap();
+    }
+    clickExhibitor2(exhibitor) {
+        this.selectExhibitor(exhibitor, true);
+        this.showMap();
+    }
+    clickExhibitor(exhibitor) {
+        window.setTimeout(() => {
+            this.clickExhibitor2(exhibitor);
+        }, navigator.userAgent.toLowerCase().indexOf('android') > -1 ? 400 : 50);
+    }
+    showMap() {
+        if (this.uiState.overlayPosition === 'bottom' && isWebGlSupported) {
+            this.uiState.desiredOverlaySize = 'medium';
+        }
+    }
+    showOverlay() {
+        if (this.uiState.overlayPosition === 'bottom')
+            this.uiState.desiredOverlaySize = 'full';
+    }
+    toggleMapOverlay() {
+        if (this.uiState.overlayPosition === 'bottom' && this.uiState.overlaySize === 'full')
+            this.uiState.desiredOverlaySize = 'medium';
+        else if (this.uiState.overlayPosition === 'bottom' && this.uiState.overlaySize !== 'full')
+            this.uiState.desiredOverlaySize = 'full';
+    }
+    /**
+     * `venueFocusAlreadyApplied`: the caller already entered the destination
+     * venue (via `focusVenueForBooths`), so this pass must not re-resolve focus,
+     * and the destination's booths count even while their level is still
+     * settling into visibility.
+     */
+    moveToList(items, venueFocusAlreadyApplied = false, cameraRequest) {
+        if (cameraRequest === undefined)
+            this.selectionCameraRequest++;
+        else if (cameraRequest !== this.selectionCameraRequest)
+            return;
+        // take only to booths and exhibitors, ignore categories
+        items = items || this.uiState.listItems;
+        const includeHidden = venueFocusAlreadyApplied && this.venueStore.hasVenueModel;
+        const booths = [];
+        items.forEach((item) => {
+            if (item instanceof Exhibitor) {
+                booths.push(...item.booths.filter((b) => b.visible || includeHidden));
+            }
+            else if (item instanceof BoothBase) {
+                if (item.visible || includeHidden)
+                    booths.push(item);
+            }
+            else if (item instanceof EventItem && item.boothId) {
+                const booth = this.boothStore.boothById.get(item.boothId);
+                if (booth && (booth.visible || includeHidden))
+                    booths.push(booth);
+            }
+            else if (item instanceof SpeakerItem) {
+                this.speakerStore.getEventsBySpeaker(item.id).forEach((e) => {
+                    if (!e.boothId)
+                        return;
+                    const booth = this.boothStore.boothById.get(e.boothId);
+                    if (booth && (booth.visible || includeHidden))
+                        booths.push(booth);
+                });
+            }
+        });
+        if (!venueFocusAlreadyApplied) {
+            focusVenueForBooths(this.venueStore, booths);
+        }
+        this.uiState.moveToBooths = booths;
+    }
+    moveToExhibitor(exhibitor) {
+        this.moveToList([exhibitor]);
+    }
+    changeActiveListIndex(delta) {
+        let newVal = this.uiState.activeListIndex + delta;
+        newVal = Math.max(0, Math.min(this.uiState.listItems.length - 1, newVal));
+        this.uiState.activeListIndex = newVal;
+    }
+    toggleModal(modalType) {
+        this.uiState.modalActive[modalType] = !this.uiState.modalActive[modalType];
+    }
+    openGallery() {
+        this.uiState.galleryActive = true;
+    }
+    closeGallery() {
+        this.uiState.galleryActive = false;
+    }
+    openActiveListItem() {
+        const item = this.uiState.listItems[this.uiState.activeListIndex];
+        if (!item)
+            return;
+        logger.log('Opening', item);
+        if (item instanceof Exhibitor) {
+            this.clickExhibitor(item);
+        }
+        else if (item instanceof Category) {
+            this.clickCategory(item);
+        }
+        else if (item instanceof BoothBase) {
+            this.clickBoothInList2(item);
+        }
+    }
+    toggleCategoryFilter() {
+        this.uiState.categoryFilterOpen = !this.uiState.categoryFilterOpen;
+    }
+    applyCategoryFilters(categories) {
+        this.uiState.selectedCategoryFilters = categories;
+        this.uiState.categoryFilterOpen = false;
+    }
+    get filteredExhibitors() {
+        if (this.uiState.selectedCategoryFilters.length === 0) {
+            return this.exhibitorStore.exhibitors;
+        }
+        return this.exhibitorStore.exhibitors.filter((exhibitor) => this.uiState.selectedCategoryFilters.some((category) => exhibitor.categories.some((c) => c.id === category.id)));
+    }
+    selectSessions() {
+        this.uiState.list = { type: 'sessions', text: '', focused: false };
+        this.uiState.menu = false;
+        this.uiState.selectedTrack = null;
+        this.searchButtonsStore.setSubButtonId(null);
+        if (this.searchButtonsStore.subButtonsEnabled) {
+            this.searchButtonsStore.showSubButtons('sessions');
+        }
+        if (isMobile) {
+            this.uiState.desiredOverlaySize = 'full';
+        }
+    }
+    selectExhibitors() {
+        this.uiState.list = { type: 'exhibitors', text: '', focused: false };
+        this.uiState.menu = false;
+        if (isMobile) {
+            this.uiState.desiredOverlaySize = 'full';
+        }
+    }
+    selectTours() {
+        this.uiState.list = { type: 'tours', text: '', focused: false };
+        this.uiState.menu = false;
+        if (isMobile) {
+            this.uiState.desiredOverlaySize = 'full';
+        }
+    }
+    selectSpeakers() {
+        this.uiState.list = { type: 'speakers', text: '', focused: false };
+        this.uiState.menu = false;
+        if (isMobile) {
+            this.uiState.desiredOverlaySize = 'full';
+        }
+    }
+    selectSpeaker(speaker, focus = true) {
+        this.speakerStore.selectSpeaker(speaker, focus);
+    }
+    resetFilters() {
+        this.searchButtonsStore.clearAllFilters();
+    }
+    registerShortcutProviders() {
+        this.shortcutRegistry.register(new SessionsShortcutProvider(this));
+        this.shortcutRegistry.register(new SpeakerShortcutProvider(this));
+        this.shortcutRegistry.register(new SearchShortcutProvider(this));
+    }
+}
+__decorate([
+    observable
+], RootStore.prototype, "initialized", void 0);
+__decorate([
+    observable
+], RootStore.prototype, "resetCameraFn", void 0);
+__decorate([
+    action
+], RootStore.prototype, "setResetCameraFn", null);
+__decorate([
+    action
+], RootStore.prototype, "selectExhibitor", null);
+__decorate([
+    action
+], RootStore.prototype, "selectBooth", null);
+__decorate([
+    action
+], RootStore.prototype, "reset", null);
+__decorate([
+    action
+], RootStore.prototype, "selectNone", null);
+__decorate([
+    action
+], RootStore.prototype, "selectBookmarks", null);
+__decorate([
+    action
+], RootStore.prototype, "selectVisited", null);
+__decorate([
+    action
+], RootStore.prototype, "selectLanguage", null);
+__decorate([
+    action
+], RootStore.prototype, "selectCategory", null);
+__decorate([
+    action
+], RootStore.prototype, "selectEventItem", null);
+__decorate([
+    action
+], RootStore.prototype, "selectSearch", null);
+__decorate([
+    action
+], RootStore.prototype, "clickBookmarks", null);
+__decorate([
+    action
+], RootStore.prototype, "clickVisited", null);
+__decorate([
+    action
+], RootStore.prototype, "clickLanguage", null);
+__decorate([
+    action
+], RootStore.prototype, "clickCategory", null);
+__decorate([
+    action
+], RootStore.prototype, "clickSeminars", null);
+__decorate([
+    action
+], RootStore.prototype, "clickBoothInList", null);
+__decorate([
+    action
+], RootStore.prototype, "clickBoothInList2", null);
+__decorate([
+    action
+], RootStore.prototype, "clickBooth", null);
+__decorate([
+    action
+], RootStore.prototype, "clickExhibitor2", null);
+__decorate([
+    action
+], RootStore.prototype, "clickExhibitor", null);
+__decorate([
+    action
+], RootStore.prototype, "showMap", null);
+__decorate([
+    action
+], RootStore.prototype, "showOverlay", null);
+__decorate([
+    action
+], RootStore.prototype, "toggleMapOverlay", null);
+__decorate([
+    action
+], RootStore.prototype, "moveToList", null);
+__decorate([
+    action
+], RootStore.prototype, "moveToExhibitor", null);
+__decorate([
+    action
+], RootStore.prototype, "changeActiveListIndex", null);
+__decorate([
+    action
+], RootStore.prototype, "toggleModal", null);
+__decorate([
+    action
+], RootStore.prototype, "openGallery", null);
+__decorate([
+    action
+], RootStore.prototype, "closeGallery", null);
+__decorate([
+    action
+], RootStore.prototype, "openActiveListItem", null);
+__decorate([
+    action
+], RootStore.prototype, "toggleCategoryFilter", null);
+__decorate([
+    action
+], RootStore.prototype, "applyCategoryFilters", null);
+__decorate([
+    computed
+], RootStore.prototype, "filteredExhibitors", null);
+__decorate([
+    action
+], RootStore.prototype, "selectSessions", null);
+__decorate([
+    action
+], RootStore.prototype, "selectExhibitors", null);
+__decorate([
+    action
+], RootStore.prototype, "selectTours", null);
+__decorate([
+    action
+], RootStore.prototype, "selectSpeakers", null);
+__decorate([
+    action
+], RootStore.prototype, "selectSpeaker", null);
+__decorate([
+    action
+], RootStore.prototype, "resetFilters", null);