@expofp/floorplan 0.0.0-experimental.cf063fc

package/dist/esm/store/MaplibreStore.d.ts

@@ -0,0 +1,71 @@
+import type RootStore from './RootStore';
+export type MaplibreViewMode = 'floorplan' | 'map2d' | 'map3d';
+/** The MapLibre camera framing, in the map's own terms. */
+export interface MaplibreCameraState {
+    lng: number;
+    lat: number;
+    zoom: number;
+    /** Degrees. */
+    bearing: number;
+    /** Degrees. */
+    pitch: number;
+}
+/**
+ * A framing to move the camera to. `bearing` and `pitch` are optional because a
+ * kiosk saved before those fields existed carries neither.
+ */
+export interface MaplibreCameraTarget {
+    lng: number;
+    lat: number;
+    zoom: number;
+    /** Degrees; omitted falls back to the venue bearing. */
+    bearing?: number;
+    /** Degrees; omitted falls back to the view mode's default pitch. */
+    pitch?: number;
+}
+/**
+ * Read/write access to the live MapLibre camera, registered by MaplibreAdapter
+ * once the map is up. In map mode the renderer runs in the renderer's external
+ * mode, where `renderer.controls` is a no-op stub that reports a zeroed camera —
+ * so anything that has to capture or restore the camera (the kiosk home framing)
+ * must go through the map itself.
+ */
+export interface MaplibreCameraPort {
+    getCameraState(): MaplibreCameraState;
+    applyCameraState(target: MaplibreCameraTarget): void;
+    /**
+     * Snaps pitch back to the view mode's default, leaving center/zoom/bearing
+     * alone — for the "fit the venue" fallback, which restores a framing through
+     * `moveToRect` (bearing only) and would otherwise leave a map3d kiosk tilted.
+     * Call it before starting that fit, not after: MapLibre runs one move at a
+     * time.
+     */
+    resetPitch(): void;
+}
+export declare function syncMaplibreVenueMode(rootStore: RootStore, showMaplibre: boolean): void;
+export default class MaplibreStore {
+    rootStore: RootStore;
+    mapViewMode: MaplibreViewMode;
+    maplibreSelected: boolean;
+    isOnline: boolean;
+    private readonly cameraPortBox;
+    private readonly handleOnline;
+    private readonly handleOffline;
+    private readonly disposeMultiVenueSync;
+    constructor(rootStore: RootStore);
+    dispose(): void;
+    setOnline(isOnline: boolean): void;
+    get cameraPort(): MaplibreCameraPort | null;
+    setCameraPort(port: MaplibreCameraPort): void;
+    /** Clears only if `port` is still the registered one — a remount may already have replaced it. */
+    clearCameraPortIfCurrent(port: MaplibreCameraPort): void;
+    activateMaplibre(): void;
+    deactivateMaplibre(): void;
+    get hideModeSwitchButton(): boolean;
+    get maplibreEnabled(): boolean;
+    get useMaplibreMap(): boolean;
+    get showMaplibre(): boolean;
+    get isMap3d(): boolean;
+    private getInitialViewMode;
+}
+//# sourceMappingURL=MaplibreStore.d.ts.map

package/dist/esm/store/MaplibreStore.js

@@ -0,0 +1,137 @@
+import { __decorate } from "tslib";
+import { action, computed, observable, reaction } from 'mobx';
+import data from '../data';
+import { getFpGeo } from '../data/fpGeo.js';
+const disable3dToggle = import.meta.env?.VITE_EXPOFP_DISABLE_3D_TOGGLE !== 'false';
+function getOnlineStatus() {
+    return typeof window === 'undefined' || window.navigator.onLine;
+}
+export function syncMaplibreVenueMode(rootStore, showMaplibre) {
+    if (showMaplibre) {
+        rootStore.venueStore.applyInitialVisibility();
+    }
+    else {
+        rootStore.venueStore.applyFallbackVisibility();
+    }
+}
+export default class MaplibreStore {
+    constructor(rootStore) {
+        this.mapViewMode = 'floorplan';
+        this.maplibreSelected = false;
+        this.isOnline = getOnlineStatus();
+        // A boxed observable rather than a decorated field: `@observable.ref` doesn't
+        // survive our tsc build, and consumers that boot before the map does (kiosk
+        // restore runs at page load) need `when(() => cameraPort)` to fire.
+        this.cameraPortBox = observable.box(null, {
+            deep: false,
+        });
+        this.handleOnline = () => this.setOnline(true);
+        this.handleOffline = () => this.setOnline(false);
+        this.rootStore = rootStore;
+        this.mapViewMode = this.getInitialViewMode();
+        this.maplibreSelected = this.mapViewMode !== 'floorplan';
+        this.disposeMultiVenueSync = reaction(() => this.showMaplibre, (showMaplibre) => syncMaplibreVenueMode(this.rootStore, showMaplibre));
+        if (typeof window !== 'undefined') {
+            window.addEventListener('online', this.handleOnline);
+            window.addEventListener('offline', this.handleOffline);
+        }
+    }
+    dispose() {
+        this.disposeMultiVenueSync();
+        if (typeof window === 'undefined')
+            return;
+        window.removeEventListener('online', this.handleOnline);
+        window.removeEventListener('offline', this.handleOffline);
+    }
+    setOnline(isOnline) {
+        this.isOnline = isOnline;
+    }
+    get cameraPort() {
+        return this.cameraPortBox.get();
+    }
+    setCameraPort(port) {
+        this.cameraPortBox.set(port);
+    }
+    /** Clears only if `port` is still the registered one — a remount may already have replaced it. */
+    clearCameraPortIfCurrent(port) {
+        if (this.cameraPortBox.get() !== port)
+            return;
+        this.cameraPortBox.set(null);
+    }
+    activateMaplibre() {
+        if (!this.maplibreEnabled)
+            return;
+        this.mapViewMode = data.allow3dView && this.mapViewMode !== 'map3d' ? 'map3d' : 'map2d';
+        this.maplibreSelected = true;
+    }
+    deactivateMaplibre() {
+        this.mapViewMode = 'floorplan';
+        this.maplibreSelected = false;
+    }
+    get hideModeSwitchButton() {
+        return (!this.maplibreEnabled || !data.allow3dView || disable3dToggle || data.hideModeSwitchButton);
+    }
+    get maplibreEnabled() {
+        const maplibreOptions = this.rootStore.fp?.maplibre ?? window['__efpMaplibre'];
+        const hasOfflineMap = !!maplibreOptions?.offline && (!!maplibreOptions.style || !!maplibreOptions.styleUrl);
+        return (this.useMaplibreMap && !!getFpGeo()?.properties?.config && (this.isOnline || hasOfflineMap));
+    }
+    get useMaplibreMap() {
+        // An explicit flag wins, `false` included — the debug-panel / localStorage
+        // override (efp-enableExperimentalMaplibre), the URL override and the host
+        // options are already layered into the effective config, which leaves the
+        // field undefined when no layer set it. Unset, the drawing decides: the
+        // Designer marks a plan authored for the map with `type: 'maplibre'`.
+        return data.enableExperimentalMaplibre ?? getFpGeo()?.properties?.config?.type === 'maplibre';
+    }
+    get showMaplibre() {
+        return this.maplibreEnabled && (this.mapViewMode === 'map2d' || this.mapViewMode === 'map3d');
+    }
+    get isMap3d() {
+        return this.maplibreEnabled && this.mapViewMode === 'map3d';
+    }
+    getInitialViewMode() {
+        if (!this.maplibreEnabled)
+            return 'floorplan';
+        return this.rootStore.uiState.is3DView ? 'map3d' : 'map2d';
+    }
+}
+__decorate([
+    observable
+], MaplibreStore.prototype, "mapViewMode", void 0);
+__decorate([
+    observable
+], MaplibreStore.prototype, "maplibreSelected", void 0);
+__decorate([
+    observable
+], MaplibreStore.prototype, "isOnline", void 0);
+__decorate([
+    action
+], MaplibreStore.prototype, "setOnline", null);
+__decorate([
+    action
+], MaplibreStore.prototype, "setCameraPort", null);
+__decorate([
+    action
+], MaplibreStore.prototype, "clearCameraPortIfCurrent", null);
+__decorate([
+    action
+], MaplibreStore.prototype, "activateMaplibre", null);
+__decorate([
+    action
+], MaplibreStore.prototype, "deactivateMaplibre", null);
+__decorate([
+    computed({ keepAlive: true })
+], MaplibreStore.prototype, "hideModeSwitchButton", null);
+__decorate([
+    computed({ keepAlive: true })
+], MaplibreStore.prototype, "maplibreEnabled", null);
+__decorate([
+    computed({ keepAlive: true })
+], MaplibreStore.prototype, "useMaplibreMap", null);
+__decorate([
+    computed({ keepAlive: true })
+], MaplibreStore.prototype, "showMaplibre", null);
+__decorate([
+    computed({ keepAlive: true })
+], MaplibreStore.prototype, "isMap3d", null);

package/dist/esm/store/OverlayStore.d.ts

@@ -0,0 +1,32 @@
+import type RootStore from './RootStore';
+/**
+ * View-model store for the overlay bottom-sheet: derives the sizing inputs the
+ * pure `<Overlay>` component needs (how tall the medium/full sheet should be)
+ * from the current UI state. Keeps this presentation math out of the Container
+ * and out of the already-large UIState.
+ */
+export default class OverlayStore {
+    private readonly rootStore;
+    constructor(rootStore: RootStore);
+    private get ui();
+    private get isRouteActive();
+    private get isSearchListOpen();
+    /**
+     * Divisor for the medium sheet height (viewportHeight / multiplier) — larger = shorter sheet.
+     *
+     * Plain `@computed`, deliberately: a `keepAlive` computed never suspends, so
+     * it stays registered on its whole transitive dependency chain — which ends
+     * at the module-scope locale box in `utils/i18n.ts`. That box outlives the
+     * plan, so a keepAlive here pins this store, its `rootStore`, the FloorPlan
+     * instance and its render target for the life of the page (ADR-0011). The
+     * body is arithmetic; there is nothing to memoize.
+     */
+    get mediumSizeMultiplier(): 3 | 7 | 9;
+    /**
+     * Pixels subtracted from viewport height for the full sheet (search box,
+     * banners, safe padding). Plain `@computed` for the reason above — this one
+     * reaches the locale box through `ui.shouldShowSearchButtons`.
+     */
+    get fullSizeOffset(): number;
+}
+//# sourceMappingURL=OverlayStore.d.ts.map

package/dist/esm/store/OverlayStore.js

@@ -0,0 +1,68 @@
+import { __decorate } from "tslib";
+import { computed } from 'mobx';
+import data from '../data';
+import { Route } from './RouteStore';
+/**
+ * View-model store for the overlay bottom-sheet: derives the sizing inputs the
+ * pure `<Overlay>` component needs (how tall the medium/full sheet should be)
+ * from the current UI state. Keeps this presentation math out of the Container
+ * and out of the already-large UIState.
+ */
+export default class OverlayStore {
+    constructor(rootStore) {
+        this.rootStore = rootStore;
+    }
+    get ui() {
+        return this.rootStore.uiState;
+    }
+    get isRouteActive() {
+        const route = this.ui.selectedRoute;
+        return !!(route?.from && route?.to);
+    }
+    get isSearchListOpen() {
+        const { list } = this.ui;
+        return list.type === 'search' || (data.isRebooking && list.type === 'exhibitors');
+    }
+    /**
+     * Divisor for the medium sheet height (viewportHeight / multiplier) — larger = shorter sheet.
+     *
+     * Plain `@computed`, deliberately: a `keepAlive` computed never suspends, so
+     * it stays registered on its whole transitive dependency chain — which ends
+     * at the module-scope locale box in `utils/i18n.ts`. That box outlives the
+     * plan, so a keepAlive here pins this store, its `rootStore`, the FloorPlan
+     * instance and its render target for the life of the page (ADR-0011). The
+     * body is arithmetic; there is nothing to memoize.
+     */
+    get mediumSizeMultiplier() {
+        if (this.isRouteActive)
+            return 7;
+        if (this.ui.details)
+            return 3;
+        if (this.isSearchListOpen)
+            return 9;
+        return 3;
+    }
+    /**
+     * Pixels subtracted from viewport height for the full sheet (search box,
+     * banners, safe padding). Plain `@computed` for the reason above — this one
+     * reaches the locale box through `ui.shouldShowSearchButtons`.
+     */
+    get fullSizeOffset() {
+        const ui = this.ui;
+        const wsHeight = ui.wsShown ? 54 : 0;
+        const bannerHeight = ui.bannerType === 'free' && !ui.freeBannerDismissed ? 40 : 0;
+        const padding = 20;
+        if (ui.details && !(ui.details instanceof Route)) {
+            return wsHeight + bannerHeight + padding;
+        }
+        const searchBoxHeight = 54;
+        const searchButtonsHeight = ui.shouldShowSearchButtons ? 54 : 0;
+        return wsHeight + bannerHeight + searchBoxHeight + padding + searchButtonsHeight;
+    }
+}
+__decorate([
+    computed
+], OverlayStore.prototype, "mediumSizeMultiplier", null);
+__decorate([
+    computed
+], OverlayStore.prototype, "fullSizeOffset", null);

package/dist/esm/store/PoiMarkerStore.d.ts

@@ -0,0 +1,76 @@
+import { type OutdoorPoiFilterState } from './outdoor-poi-filter';
+import type RootStore from './RootStore';
+/**
+ * A rendered outdoor PoI marker, shared between the place that creates it
+ * (`config-outdoor-poi`) and the consumer that renders it as native MapLibre
+ * symbol/cluster layers (`usePoiMarkers`).
+ *
+ * `icon` is the category pin — poiType glyph and Designer color baked in —
+ * rasterized once at devicePixelRatio and handed to `map.addImage`. (The
+ * selection pinhead is not per-marker: usePoiMarkers draws one shared image.)
+ * `center` is the PoI position in SVG/model coordinates (booth rect center);
+ * everything else about marker state (selection, filtering, clustering) is
+ * derived at render time from the stores, not stored here.
+ */
+export interface PoiMarker {
+    boothId: number;
+    center: {
+        x: number;
+        y: number;
+    };
+    icon: ImageData;
+}
+/**
+ * Domain store for the current outdoor PoI markers. `config-outdoor-poi`
+ * publishes the rasterized markers here; `usePoiMarkers` renders them as
+ * native MapLibre layers, and dimming/filtering read them via MobX.
+ *
+ * Selection is not stored: {@link selectedMarkerId} derives it from
+ * `uiState.selectedBooths` (the single selected booth, if it has a marker),
+ * so `RootStore.clickBooth` / search selection are the only writers.
+ */
+export default class PoiMarkerStore {
+    readonly rootStore: RootStore;
+    /**
+     * Backing box for {@link markers}, reference-observed (`deep: false`):
+     * PoiMarker holds raster data that must not be deep-observed. A box instead of
+     * an `@observable.ref` field because mobx 5's field-decorator typing
+     * predates TS standard decorators (the @-form fails to type-check), and the
+     * runtime `decorate()` alternative silently breaks under native class-field
+     * (define) semantics, which vitest's transform uses.
+     */
+    private readonly markersBox;
+    /**
+     * Monotonic counter bumped by {@link clear}. Async marker producers capture
+     * it before awaiting and compare before {@link addMany}, so icon loads that
+     * outlive a scene teardown/rebuild cannot repopulate the store with stale
+     * markers.
+     */
+    generation: number;
+    constructor(rootStore: RootStore);
+    /** The current markers; the array is replaced wholesale, never mutated. */
+    get markers(): readonly PoiMarker[];
+    /** Registers a batch of markers with a single change notification. */
+    addMany(newMarkers: readonly PoiMarker[]): void;
+    clear(): void;
+    /**
+     * The marker shown as the selection pinhead: the single selected booth, if
+     * exactly one booth is selected and it has an outdoor marker. Multi-select
+     * (routes, multi-booth exhibitors) shows no per-marker highlight.
+     */
+    get selectedMarkerId(): number | null;
+    /** Whether an outdoor marker is selected — suppresses venue dimming. */
+    get selectionActive(): boolean;
+    /**
+     * The active poiType filter narrowed to the markers it actually renders.
+     * Cached: it scans every booth, and the map reads it from several places
+     * (marker data, camera fit, dimming) on every selection or filter change.
+     */
+    get outdoorFilter(): OutdoorPoiFilterState;
+    /**
+     * Dimming is suppressed while an outdoor PoI filter or marker selection is
+     * active — the whole point of both is to make those markers stand out.
+     */
+    get dimSuppressed(): boolean;
+}
+//# sourceMappingURL=PoiMarkerStore.d.ts.map

package/dist/esm/store/PoiMarkerStore.js

@@ -0,0 +1,97 @@
+import { __decorate } from "tslib";
+import { action, computed, observable } from 'mobx';
+import { computeOutdoorPoiFilterState } from './outdoor-poi-filter';
+/**
+ * Domain store for the current outdoor PoI markers. `config-outdoor-poi`
+ * publishes the rasterized markers here; `usePoiMarkers` renders them as
+ * native MapLibre layers, and dimming/filtering read them via MobX.
+ *
+ * Selection is not stored: {@link selectedMarkerId} derives it from
+ * `uiState.selectedBooths` (the single selected booth, if it has a marker),
+ * so `RootStore.clickBooth` / search selection are the only writers.
+ */
+export default class PoiMarkerStore {
+    constructor(rootStore) {
+        /**
+         * Backing box for {@link markers}, reference-observed (`deep: false`):
+         * PoiMarker holds raster data that must not be deep-observed. A box instead of
+         * an `@observable.ref` field because mobx 5's field-decorator typing
+         * predates TS standard decorators (the @-form fails to type-check), and the
+         * runtime `decorate()` alternative silently breaks under native class-field
+         * (define) semantics, which vitest's transform uses.
+         */
+        this.markersBox = observable.box([], { deep: false });
+        /**
+         * Monotonic counter bumped by {@link clear}. Async marker producers capture
+         * it before awaiting and compare before {@link addMany}, so icon loads that
+         * outlive a scene teardown/rebuild cannot repopulate the store with stale
+         * markers.
+         */
+        this.generation = 0;
+        this.rootStore = rootStore;
+    }
+    /** The current markers; the array is replaced wholesale, never mutated. */
+    get markers() {
+        return this.markersBox.get();
+    }
+    /** Registers a batch of markers with a single change notification. */
+    addMany(newMarkers) {
+        if (!newMarkers.length)
+            return;
+        this.markersBox.set([...this.markers, ...newMarkers]);
+    }
+    clear() {
+        this.generation += 1;
+        this.markersBox.set([]);
+    }
+    /**
+     * The marker shown as the selection pinhead: the single selected booth, if
+     * exactly one booth is selected and it has an outdoor marker. Multi-select
+     * (routes, multi-booth exhibitors) shows no per-marker highlight.
+     */
+    get selectedMarkerId() {
+        const selectedBooths = [...this.rootStore.uiState.selectedBooths];
+        const selected = selectedBooths.length === 1 ? selectedBooths[0] : undefined;
+        if (!selected)
+            return null;
+        return this.markers.some((marker) => marker.boothId === selected.id) ? selected.id : null;
+    }
+    /** Whether an outdoor marker is selected — suppresses venue dimming. */
+    get selectionActive() {
+        return this.selectedMarkerId !== null;
+    }
+    /**
+     * The active poiType filter narrowed to the markers it actually renders.
+     * Cached: it scans every booth, and the map reads it from several places
+     * (marker data, camera fit, dimming) on every selection or filter change.
+     */
+    get outdoorFilter() {
+        const { uiState, boothStore } = this.rootStore;
+        return computeOutdoorPoiFilterState(uiState.selectedPoiTypeFilters.map((poiType) => poiType.id), uiState.selectedCategoryFilters.length > 0, boothStore.booths, this.markers);
+    }
+    /**
+     * Dimming is suppressed while an outdoor PoI filter or marker selection is
+     * active — the whole point of both is to make those markers stand out.
+     */
+    get dimSuppressed() {
+        return this.outdoorFilter.active || this.selectionActive;
+    }
+}
+__decorate([
+    action
+], PoiMarkerStore.prototype, "addMany", null);
+__decorate([
+    action
+], PoiMarkerStore.prototype, "clear", null);
+__decorate([
+    computed({ keepAlive: true })
+], PoiMarkerStore.prototype, "selectedMarkerId", null);
+__decorate([
+    computed({ keepAlive: true })
+], PoiMarkerStore.prototype, "selectionActive", null);
+__decorate([
+    computed({ keepAlive: true })
+], PoiMarkerStore.prototype, "outdoorFilter", null);
+__decorate([
+    computed({ keepAlive: true })
+], PoiMarkerStore.prototype, "dimSuppressed", null);

package/dist/esm/store/PoiTypeStore.d.ts

@@ -0,0 +1,8 @@
+import { RawPoiType } from '@expofp/schema';
+import RootStore from './RootStore';
+export default class PoiTypeStore {
+    private readonly rootStore;
+    readonly poiTypes: RawPoiType[];
+    constructor(rootStore: RootStore);
+}
+//# sourceMappingURL=PoiTypeStore.d.ts.map

package/dist/esm/store/PoiTypeStore.js

@@ -0,0 +1,6 @@
+export default class PoiTypeStore {
+    constructor(rootStore) {
+        this.poiTypes = [];
+        this.rootStore = rootStore;
+    }
+}

package/dist/esm/store/RootStore.d.ts

@@ -0,0 +1,118 @@
+import FloorPlanReady from '../floorplan.ready';
+import { URLFilterManager } from '../services/URLFilterManager';
+import BookmarksStore from './BookmarksStore';
+import BoothStore, { Booth } 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 from './LayerStore';
+import MaplibreStore from './MaplibreStore';
+import OverlayStore from './OverlayStore';
+import PoiMarkerStore from './PoiMarkerStore';
+import PoiTypeStore from './PoiTypeStore';
+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 { Speaker } from './SpeakerStore';
+import ToursStore from './ToursStore';
+import type { ListItem } from './types';
+import UIState from './UIState';
+import VenueStore from './VenueStore';
+export default class RootStore {
+    readonly categoryStore: CategoryStore;
+    readonly exhibitorStore: ExhibitorStore;
+    readonly boothStore: BoothStore;
+    readonly uiState: UIState;
+    readonly overlayStore: OverlayStore;
+    readonly routeStore: RouteStore;
+    readonly routePlannerStore: RoutePlannerStore;
+    readonly toursStore: ToursStore;
+    readonly maplibreStore: MaplibreStore;
+    readonly layerStore: LayerStore;
+    readonly venueStore: VenueStore;
+    readonly intercomStore: IntercomStore;
+    readonly eventStore: EventStore;
+    readonly poiTypeStore: PoiTypeStore;
+    readonly poiMarkerStore: PoiMarkerStore;
+    readonly heatmapStore: HeatmapStore;
+    readonly fuzzySearchEngineStore: FuzzySearchEngineStore;
+    readonly categoryFilterStore: CategoryFilterStore;
+    readonly sessionsFilterStore: SessionsFilterStore;
+    readonly speakerStore: SpeakerStore;
+    readonly speakerFilterStore: SpeakerFilterStore;
+    readonly searchStore: SearchStore;
+    readonly searchButtonsStore: SearchButtonsStore;
+    readonly bookmarksStore: BookmarksStore;
+    readonly urlFilterManager: URLFilterManager;
+    readonly shortcutRegistry: ShortcutRegistry;
+    private selectionCameraRequest;
+    fp: FloorPlanReady;
+    initialized: boolean;
+    resetCameraFn: () => void;
+    setResetCameraFn(resetCameraFn: () => void): void;
+    constructor();
+    /**
+     * 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.
+     */
+    private scheduleSelectionCamera;
+    selectExhibitor(exhibitor: Exhibitor, focus?: boolean): void;
+    selectBooth(booth: Booth | Booth[], focus?: boolean): void;
+    reset(): void;
+    selectNone(): void;
+    selectBookmarks(): void;
+    selectVisited(): void;
+    selectLanguage(): void;
+    selectCategory(category: Category): void;
+    selectEventItem(eventItem: EventItem, focus?: boolean): void;
+    selectSearch(text?: string): void;
+    clickBookmarks(): void;
+    clickVisited(): void;
+    clickLanguage(): void;
+    clickCategory(category: Category): void;
+    clickSeminars(): void;
+    clickBoothInList(booth: Booth): void;
+    clickBoothInList2(booth: Booth): void;
+    clickBooth(booth: Booth | null): void;
+    clickExhibitor2(exhibitor: Exhibitor): void;
+    clickExhibitor(exhibitor: Exhibitor): void;
+    showMap(): void;
+    showOverlay(): void;
+    toggleMapOverlay(): void;
+    /**
+     * `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?: ListItem[], venueFocusAlreadyApplied?: boolean, cameraRequest?: number): void;
+    moveToExhibitor(exhibitor: Exhibitor): void;
+    changeActiveListIndex(delta: 1 | 0 | -1): void;
+    toggleModal(modalType: 'share'): void;
+    openGallery(): void;
+    closeGallery(): void;
+    openActiveListItem(): void;
+    toggleCategoryFilter(): void;
+    applyCategoryFilters(categories: Category[]): void;
+    get filteredExhibitors(): Exhibitor[];
+    selectSessions(): void;
+    selectExhibitors(): void;
+    selectTours(): void;
+    selectSpeakers(): void;
+    selectSpeaker(speaker: Speaker, focus?: boolean): void;
+    resetFilters(): void;
+    private registerShortcutProviders;
+}
+//# sourceMappingURL=RootStore.d.ts.map