@expofp/floorplan 0.0.0-experimental.cf063fc

package/dist/esm/store/search-buttons/SearchButtonsStore.js

@@ -0,0 +1,364 @@
+import { __decorate } from "tslib";
+import { action, computed } from 'mobx';
+import { CACHE_DURATION, LANGUAGE_TYPE, MOBILE_BREAKPOINT } from '../../constants';
+import data from '../../data';
+import { planReaction } from '../../utils/plan-reactions.js';
+import { SessionsSubButtonProvider } from '../providers/SessionsSubButtonProvider';
+import { SubButtonRegistry } from '../SubButtonRegistry';
+import { PREFIXES } from './constants';
+import { SearchButtonsActions } from './SearchButtonsActions';
+import { SearchButtonsFactory } from './SearchButtonsFactory';
+import { SearchButtonsFilters } from './SearchButtonsFilters';
+import { SearchButtonsState } from './SearchButtonsState';
+import { countMapValues, extractPoiTypeId, isValidConfig } from './utils';
+export default class SearchButtonsStore {
+    constructor(rootStore) {
+        this.poiTypeCountsCache = new Map();
+        /** Set by `keepFiltersOnNextNavigation`, spent by the next entry into navigation. */
+        this.keepFiltersOnNextEntry = false;
+        this.lastPoiTypeCountUpdate = 0;
+        this.rootStore = rootStore;
+        this.state = new SearchButtonsState();
+        this.filters = new SearchButtonsFilters(rootStore, this.state);
+        this.actions = new SearchButtonsActions(rootStore, this.state, this.filters);
+        this.factory = new SearchButtonsFactory(rootStore, this.state, this.actions);
+        this.setupReactions();
+    }
+    setupReactions() {
+        planReaction(() => this.rootStore.boothStore.booths.length, () => this.invalidatePoiTypeCounts());
+        // Only the step into navigation turns the button off: a filter the user
+        // turns on again while navigating stays on, and closing navigation does
+        // not bring the old one back.
+        planReaction(() => this.isNavigationOpen, (open) => {
+            if (!open)
+                return;
+            if (this.keepFiltersOnNextEntry) {
+                this.keepFiltersOnNextEntry = false;
+                return;
+            }
+            this.actions.deactivateForNavigation();
+        });
+    }
+    /**
+     * Lets the next entry into navigation keep the active filter. For a deep
+     * link that opens with both a filter and a route or planner: that is not a
+     * switch into navigation, so its filter stays. Call it only right before
+     * opening navigation that is sure to land, or the hold outlives it and
+     * spares the user's own next entry.
+     */
+    keepFiltersOnNextNavigation() {
+        this.keepFiltersOnNextEntry = true;
+    }
+    /**
+     * Navigation is the route planner or the directions panel. The planner opens
+     * before its route is drawn, so a planner session counts as one entry.
+     */
+    get isNavigationOpen() {
+        const { uiState } = this.rootStore;
+        return uiState.selectedRoute !== null || uiState.list.type === 'route-planner';
+    }
+    get subButtonRegistry() {
+        if (!this._subButtonRegistry) {
+            this._subButtonRegistry = new SubButtonRegistry();
+            this.registerSubButtonProviders();
+        }
+        return this._subButtonRegistry;
+    }
+    registerSubButtonProviders() {
+        this.subButtonRegistry.register(new SessionsSubButtonProvider(this.rootStore));
+    }
+    invalidatePoiTypeCounts() {
+        this.poiTypeCountsCache.clear();
+        this.lastPoiTypeCountUpdate = 0;
+    }
+    get isVisible() {
+        return this.state.isVisible;
+    }
+    get shouldShow() {
+        const { uiState } = this.rootStore;
+        const isDesktop = uiState.screenSize.width >= MOBILE_BREAKPOINT;
+        if (isDesktop)
+            return this.state.isVisible;
+        const hasDetailsOpen = !!(uiState.selectedExhibitor ||
+            uiState.selectedBooth ||
+            uiState.selectedEventItem ||
+            uiState.selectedRoute ||
+            uiState.menu ||
+            uiState.list.type === LANGUAGE_TYPE);
+        return this.state.isVisible && !hasDetailsOpen;
+    }
+    get activePoiFilterId() {
+        return this.state.activePoiFilterId;
+    }
+    get activeSubButtonsParentId() {
+        return this.state.activeSubButtonsParentId;
+    }
+    get activeSubButtonId() {
+        return this.state.activeSubButtonId;
+    }
+    get subButtonsEnabled() {
+        return this.state.subButtonsEnabled;
+    }
+    get searchShortcutState() {
+        return this.state.searchShortcutState;
+    }
+    get searchButtons() {
+        // legacy `data.js` field with no schema counterpart yet; `isValidConfig`
+        // below is what actually narrows it
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const filterConfig = data.filterButtonsConfig;
+        if (!isValidConfig(filterConfig)) {
+            console.warn('[SearchButtonsStore] Invalid filterButtonsConfig detected');
+            return [];
+        }
+        const searchButtonConfigs = filterConfig.searchButtons;
+        return this.factory.createButtons(searchButtonConfigs);
+    }
+    get hasAnySearchButtons() {
+        return this.searchButtons.length > 0;
+    }
+    get hasActiveSearchButton() {
+        return (this.state.activePoiFilterId !== null ||
+            this.rootStore.uiState.selectedCategoryFilters.length > 0);
+    }
+    get activeSearchButtonLabel() {
+        if (this.state.activePoiFilterId) {
+            const searchButton = this.searchButtons.find((f) => f.id === this.state.activePoiFilterId);
+            return searchButton?.label || null;
+        }
+        if (this.rootStore.uiState.selectedCategoryFilters.length > 0) {
+            return 'Categories';
+        }
+        return null;
+    }
+    get activeSubButtons() {
+        if (!this.state.activeSubButtonsParentId)
+            return [];
+        return this.subButtonRegistry.getSubButtons(this.state.activeSubButtonsParentId);
+    }
+    get shouldShowSubButtons() {
+        if (!this.state.subButtonsEnabled || !this.state.activeSubButtonsParentId) {
+            return false;
+        }
+        const parentButton = this.searchButtons.find((btn) => btn.id === this.state.activeSubButtonsParentId);
+        if (!parentButton || !parentButton.active)
+            return false;
+        return (this.subButtonRegistry.shouldShowSubButtons(this.state.activeSubButtonsParentId) &&
+            this.activeSubButtons.length > 0);
+    }
+    get hasActiveParentWithChildren() {
+        return this.state.hasActiveParentWithChildren;
+    }
+    get areAllSelected() {
+        return this.filters.areAllSelected();
+    }
+    get activeChildrenCount() {
+        return this.state.activeChildrenCount;
+    }
+    get totalChildrenCount() {
+        return this.filters.getChildrenCount();
+    }
+    get poiTypeCounts() {
+        const now = Date.now();
+        if (now - this.lastPoiTypeCountUpdate < CACHE_DURATION && this.poiTypeCountsCache.size > 0) {
+            return this.poiTypeCountsCache;
+        }
+        const counts = new Map();
+        this.rootStore.boothStore.booths.forEach((booth) => {
+            if (booth.poiTypeId) {
+                counts.set(booth.poiTypeId, (counts.get(booth.poiTypeId) || 0) + 1);
+            }
+        });
+        this.poiTypeCountsCache = counts;
+        this.lastPoiTypeCountUpdate = now;
+        return counts;
+    }
+    get totalPoiTypeCount() {
+        return countMapValues(this.poiTypeCounts);
+    }
+    get activePoiTypeId() {
+        if (this.state.activePoiFilterId?.startsWith(PREFIXES.POI_TYPE)) {
+            return extractPoiTypeId(this.state.activePoiFilterId);
+        }
+        return null;
+    }
+    handleSearchButtonClick(searchButtonId, caption) {
+        this.actions.handleSearchButtonClick(searchButtonId, caption);
+    }
+    handleExtendedSearchButtonClick(buttonId) {
+        this.actions.handleExtendedSearchButtonClick(buttonId);
+    }
+    handleMainButtonClick(buttonId) {
+        this.actions.handleMainButtonClick(buttonId);
+    }
+    handleSessionsClick(caption) {
+        this.actions.handleSessionsClick(caption);
+    }
+    togglePoiType(poiTypeId) {
+        this.actions.togglePoiType(poiTypeId);
+    }
+    clearAllFilters() {
+        this.actions.clearAllFilters();
+    }
+    showSubButtons(parentButtonId) {
+        this.actions.showSubButtons(parentButtonId);
+    }
+    hideSubButtons() {
+        this.actions.hideSubButtons();
+    }
+    handleSubButtonClick(subButtonId) {
+        if (this.state.activeSubButtonId === subButtonId)
+            return;
+        this.state.setSubButton(subButtonId);
+        if (this.state.activeSubButtonsParentId) {
+            this.subButtonRegistry.handleSubButtonClick(this.state.activeSubButtonsParentId, subButtonId);
+        }
+    }
+    toggleChildFilter(childId) {
+        this.filters.toggleChildFilter(childId);
+    }
+    clearPoiTypeFilters() {
+        this.filters.clearPoiTypeFilters();
+    }
+    clearAllChildFilters() {
+        this.filters.clearAllChildFilters();
+    }
+    setActiveParentId(parentId) {
+        this.state.setActiveParentId(parentId);
+    }
+    showShortcuts(visible) {
+        this.state.showShortcuts(visible);
+    }
+    clearChildren() {
+        this.state.clearChildren();
+    }
+    setSubButtonId(buttonId) {
+        this.state.setSubButton(buttonId);
+    }
+    setPoiFilterId(filterId) {
+        this.state.setPoiFilter(filterId);
+    }
+    getPoiTypeTotalCount(poiTypeId) {
+        return this.poiTypeCounts.get(poiTypeId) || 0;
+    }
+    isChildActive(childId) {
+        return this.state.isChildActive(childId);
+    }
+    getActiveParent() {
+        return this.filters.getActiveParent();
+    }
+}
+__decorate([
+    action
+], SearchButtonsStore.prototype, "invalidatePoiTypeCounts", null);
+__decorate([
+    computed
+], SearchButtonsStore.prototype, "isVisible", null);
+__decorate([
+    computed
+], SearchButtonsStore.prototype, "shouldShow", null);
+__decorate([
+    computed
+], SearchButtonsStore.prototype, "activePoiFilterId", null);
+__decorate([
+    computed
+], SearchButtonsStore.prototype, "activeSubButtonsParentId", null);
+__decorate([
+    computed
+], SearchButtonsStore.prototype, "activeSubButtonId", null);
+__decorate([
+    computed
+], SearchButtonsStore.prototype, "subButtonsEnabled", null);
+__decorate([
+    computed
+], SearchButtonsStore.prototype, "searchShortcutState", null);
+__decorate([
+    computed
+], SearchButtonsStore.prototype, "searchButtons", null);
+__decorate([
+    computed
+], SearchButtonsStore.prototype, "hasAnySearchButtons", null);
+__decorate([
+    computed
+], SearchButtonsStore.prototype, "hasActiveSearchButton", null);
+__decorate([
+    computed
+], SearchButtonsStore.prototype, "activeSearchButtonLabel", null);
+__decorate([
+    computed
+], SearchButtonsStore.prototype, "activeSubButtons", null);
+__decorate([
+    computed
+], SearchButtonsStore.prototype, "shouldShowSubButtons", null);
+__decorate([
+    computed
+], SearchButtonsStore.prototype, "hasActiveParentWithChildren", null);
+__decorate([
+    computed
+], SearchButtonsStore.prototype, "areAllSelected", null);
+__decorate([
+    computed
+], SearchButtonsStore.prototype, "activeChildrenCount", null);
+__decorate([
+    computed
+], SearchButtonsStore.prototype, "totalChildrenCount", null);
+__decorate([
+    computed
+], SearchButtonsStore.prototype, "poiTypeCounts", null);
+__decorate([
+    computed
+], SearchButtonsStore.prototype, "totalPoiTypeCount", null);
+__decorate([
+    computed
+], SearchButtonsStore.prototype, "activePoiTypeId", null);
+__decorate([
+    action
+], SearchButtonsStore.prototype, "handleSearchButtonClick", null);
+__decorate([
+    action
+], SearchButtonsStore.prototype, "handleExtendedSearchButtonClick", null);
+__decorate([
+    action
+], SearchButtonsStore.prototype, "handleMainButtonClick", null);
+__decorate([
+    action
+], SearchButtonsStore.prototype, "handleSessionsClick", null);
+__decorate([
+    action
+], SearchButtonsStore.prototype, "togglePoiType", null);
+__decorate([
+    action
+], SearchButtonsStore.prototype, "clearAllFilters", null);
+__decorate([
+    action
+], SearchButtonsStore.prototype, "showSubButtons", null);
+__decorate([
+    action
+], SearchButtonsStore.prototype, "hideSubButtons", null);
+__decorate([
+    action
+], SearchButtonsStore.prototype, "handleSubButtonClick", null);
+__decorate([
+    action
+], SearchButtonsStore.prototype, "toggleChildFilter", null);
+__decorate([
+    action
+], SearchButtonsStore.prototype, "clearPoiTypeFilters", null);
+__decorate([
+    action
+], SearchButtonsStore.prototype, "clearAllChildFilters", null);
+__decorate([
+    action
+], SearchButtonsStore.prototype, "setActiveParentId", null);
+__decorate([
+    action
+], SearchButtonsStore.prototype, "showShortcuts", null);
+__decorate([
+    action
+], SearchButtonsStore.prototype, "clearChildren", null);
+__decorate([
+    action
+], SearchButtonsStore.prototype, "setSubButtonId", null);
+__decorate([
+    action
+], SearchButtonsStore.prototype, "setPoiFilterId", null);

package/dist/esm/store/search-buttons/constants.d.ts

@@ -0,0 +1,24 @@
+export declare enum SearchButtonType {
+    BOOKMARKS = "bookmarks",
+    VISITED = "visited",
+    SESSIONS = "sessions",
+    TOURS = "guided_tours",
+    CATEGORIES = "categories",
+    POI_TYPE = "poi_type",
+    POI_TYPES = "poi_types",
+    LINK = "link",
+    EXHIBITORS = "exhibitors"
+}
+export declare const PREFIXES: {
+    readonly POI_TYPE: 'poiType_';
+    readonly CATEGORIES: 'categories_';
+    readonly POI_TYPES: 'poi_types_';
+    readonly LINK: 'link_';
+};
+export declare const BUTTON_ICONS: {
+    readonly BOOKMARKS: 'icon-bookmark';
+    readonly VISITED: 'icon-checkmark';
+    readonly SESSIONS: 'icon-schedule';
+    readonly EXHIBITORS: 'icon-exhibitors';
+};
+//# sourceMappingURL=constants.d.ts.map

package/dist/esm/store/search-buttons/constants.js

@@ -0,0 +1,24 @@
+export var SearchButtonType;
+(function (SearchButtonType) {
+    SearchButtonType["BOOKMARKS"] = "bookmarks";
+    SearchButtonType["VISITED"] = "visited";
+    SearchButtonType["SESSIONS"] = "sessions";
+    SearchButtonType["TOURS"] = "guided_tours";
+    SearchButtonType["CATEGORIES"] = "categories";
+    SearchButtonType["POI_TYPE"] = "poi_type";
+    SearchButtonType["POI_TYPES"] = "poi_types";
+    SearchButtonType["LINK"] = "link";
+    SearchButtonType["EXHIBITORS"] = "exhibitors";
+})(SearchButtonType || (SearchButtonType = {}));
+export const PREFIXES = {
+    POI_TYPE: 'poiType_',
+    CATEGORIES: 'categories_',
+    POI_TYPES: 'poi_types_',
+    LINK: 'link_',
+};
+export const BUTTON_ICONS = {
+    BOOKMARKS: 'icon-bookmark',
+    VISITED: 'icon-checkmark',
+    SESSIONS: 'icon-schedule',
+    EXHIBITORS: 'icon-exhibitors',
+};

package/dist/esm/store/search-buttons/index.d.ts

@@ -0,0 +1,8 @@
+export { default as SearchButtonsStore } from './SearchButtonsStore';
+export { SearchButtonsFactory } from './SearchButtonsFactory';
+export { SearchButtonsActions } from './SearchButtonsActions';
+export { SearchButtonsFilters } from './SearchButtonsFilters';
+export { SearchButtonsState } from './SearchButtonsState';
+export * from './constants';
+export type { SearchButtonConfig, SearchButtonTypeConfig, SearchButtonChild, SearchShortcutState, } from '../types';
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/store/search-buttons/index.js

@@ -0,0 +1,7 @@
+/* eslint-disable simple-import-sort/exports */
+export { default as SearchButtonsStore } from './SearchButtonsStore';
+export { SearchButtonsFactory } from './SearchButtonsFactory';
+export { SearchButtonsActions } from './SearchButtonsActions';
+export { SearchButtonsFilters } from './SearchButtonsFilters';
+export { SearchButtonsState } from './SearchButtonsState';
+export * from './constants';

package/dist/esm/store/search-buttons/utils.d.ts

@@ -0,0 +1,6 @@
+import { type SearchButtonTypeConfig } from '../types';
+export declare function extractPoiTypeId(filterId: string): number | null;
+export declare function getButtonConfig(buttonId: string): SearchButtonTypeConfig | null;
+export declare function countMapValues(map: Map<any, number>): number;
+export declare function isValidConfig(config: any): boolean;
+//# sourceMappingURL=utils.d.ts.map

package/dist/esm/store/search-buttons/utils.js

@@ -0,0 +1,34 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import data from '../../data';
+import { PREFIXES } from './constants';
+export function extractPoiTypeId(filterId) {
+    try {
+        const idStr = filterId.replace(PREFIXES.POI_TYPE, '');
+        const id = parseInt(idStr, 10);
+        return isNaN(id) ? null : id;
+    }
+    catch {
+        return null;
+    }
+}
+export function getButtonConfig(buttonId) {
+    const filterConfig = data.filterButtonsConfig;
+    if (!filterConfig?.searchButtons || !Array.isArray(filterConfig.searchButtons)) {
+        return null;
+    }
+    const searchButtons = filterConfig.searchButtons;
+    return searchButtons.find((btn) => btn.id === buttonId) || null;
+}
+export function countMapValues(map) {
+    let total = 0;
+    for (const value of map.values()) {
+        total += value;
+    }
+    return total;
+}
+export function isValidConfig(config) {
+    return (config &&
+        typeof config === 'object' &&
+        Array.isArray(config.searchButtons) &&
+        config.searchButtons.length > 0);
+}

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

@@ -0,0 +1,213 @@
+import { type RawPoiType } from '@expofp/schema';
+import type { AutocompleteOptionObject } from '@expofp/ui';
+import { type Language } from '../types';
+import type { Booth } from './BoothStore';
+import type { Category } from './CategoryStore';
+import type { EventItem, Track } from './EventStore';
+import type { Exhibitor } from './ExhibitorStore';
+import type { HeatmapYah } from './HeatmapStore';
+import type RootStore from './RootStore';
+import { type PlannerSource } from './RoutePlannerStore';
+import type { SpeakerItem } from './SpeakerStore';
+export interface FilterType {
+    type: 'filter';
+    items: ListItem[];
+    query: {
+        key: string;
+        value: string;
+    };
+}
+export type ListType = {
+    type: 'search';
+    text: string;
+    focused: boolean;
+} | {
+    type: 'exhibitors';
+    text: string;
+    focused: boolean;
+} | {
+    type: 'bookmarks';
+} | {
+    type: 'visited';
+} | {
+    type: 'category';
+    category: Category;
+} | {
+    type: 'language';
+} | FilterType | {
+    type: 'sessions';
+    text: string;
+    focused: boolean;
+} | {
+    type: 'speakers';
+    text: string;
+    focused: boolean;
+} | {
+    type: 'tours';
+    text: string;
+    focused: boolean;
+} | {
+    type: 'multi-point-tour';
+    tourId: string;
+} | {
+    type: 'route-planner';
+    source: PlannerSource;
+};
+export declare const SESSIONS_LIST_TYPE = "sessions";
+export type OverlaySize = 'full' | 'medium' | 'small';
+export type ListItem = Booth | Exhibitor | Category | EventItem | SpeakerItem | Language | HeatmapYah;
+export interface Visibility {
+    controls?: boolean;
+    levels?: boolean;
+    header?: boolean;
+    overlay?: boolean;
+    searchButtons?: boolean;
+}
+export type BannerType = 'demo' | 'free' | null;
+export interface FilterItem {
+    id: number | string;
+    name: string;
+}
+export interface FilterGroup {
+    groupName: string;
+    items: FilterItem[];
+    fullWidth?: boolean;
+}
+export interface FilterState {
+    isOpen: boolean;
+    selectedItems: FilterItem[];
+    pendingItems: FilterItem[];
+}
+export interface FilterStore {
+    state: FilterState;
+    openFilter(): void;
+    closeFilter(): void;
+    applyFilter(): void;
+    resetFilter(): void;
+    clearPendingItems(): void;
+    setPendingItems(items: FilterItem[]): void;
+    getFilteredItems(): FilterItem[];
+    publicRootStore: RootStore;
+}
+export interface URLFilters {
+    categories: string[];
+    poiType: string | null;
+    poiTypes: string[];
+    exhibitors: boolean;
+}
+export interface TourItem {
+    id: string;
+    layers: {
+        floor: string;
+        id: string;
+    }[];
+    name: string;
+    description?: string;
+    points?: string[];
+}
+export interface GlobalFilterState {
+    categories: Category[];
+    poiType: RawPoiType | null;
+    isActive: boolean;
+}
+export interface MapSettings {
+    /** How long a zoom takes, in milliseconds. Clamped to 500-5000. */
+    zoomtime?: number;
+    /** How long a tilt takes, in milliseconds. Clamped to 500-5000. */
+    pitchtime?: number;
+    /** Where the map is centered, in WGS84 as `"lat,lng"`. Paired with nothing; `centerxy` wins. */
+    center?: string;
+    /** Where the map is centered, in projected plan units as `"x,y"`. */
+    centerxy?: string;
+    /** The floor to activate, by name. */
+    z?: string;
+    /** The venue to activate, by id (multi-venue plans); a display name resolves nothing. */
+    venue?: string;
+    /** The angle to turn the plan to, in degrees from north, 0 to 360. */
+    bearing?: number;
+    /** Whether the user may turn the plan by hand. Says nothing about a camera command. */
+    roll?: 0 | 1;
+    /** Whether the user may tilt the plan by hand. Says nothing about a camera command. */
+    pitch?: 0 | 1;
+    /** The angle to tilt the plan back from top down to, in degrees. */
+    pitchdegrees?: number;
+}
+export interface SearchButtonChild {
+    id?: number | string;
+    type: 'poi_types' | 'categories';
+    name: string;
+    visible: boolean;
+    count?: number;
+}
+export interface SearchButtonLinkChild {
+    type: 'link';
+    visible: boolean;
+    linkUrl: string;
+}
+export interface SearchShortcutState {
+    activeParentId: string | null;
+    activeChildren: Set<string>;
+    isShortcutsVisible: boolean;
+}
+export interface SearchSubButtonConfig {
+    id: string;
+    label: string;
+    icon?: string;
+    text?: string;
+    enabled: boolean;
+    active: boolean;
+    count?: number;
+    parentButtonId: string;
+    type: 'show_all' | 'track';
+    data?: Track;
+    onClick: () => void;
+}
+export interface SearchButtonConfig {
+    id: string;
+    label: string;
+    icon?: string;
+    text?: string;
+    enabled: boolean;
+    active: boolean;
+    count?: number;
+    modalComponent?: React.ComponentType;
+    isDimmed?: boolean;
+    isClickable?: boolean;
+    showZeroCount?: boolean;
+    hasSubButtons?: boolean;
+    subButtons?: SearchSubButtonConfig[];
+    backgroundColor?: string;
+    textColor?: string;
+    onClick: () => void;
+}
+export interface SearchButtonTypeConfig {
+    id?: string;
+    type: 'sessions' | 'bookmarks' | 'visited' | 'categories' | 'poi_type' | 'poi_types' | 'link' | 'guided_tours' | 'exhibitors';
+    name: string;
+    visible: boolean;
+    builtIn?: boolean;
+    order?: number;
+    color?: string;
+    children?: (SearchButtonChild | {
+        type: 'link';
+        visible: boolean;
+        linkUrl: string;
+    })[];
+}
+export interface InterfaceAction {
+    id: string;
+    icon: string;
+    label: string;
+    handler: () => void;
+}
+/**
+ * A wayfinding autocomplete option. `@expofp/ui`'s own option shape is
+ * presentational — value and label only — and `AutocompleteProps` is generic
+ * over it precisely so a domain can carry its own fields; `exhibitorId` is the
+ * one the route planner needs, to tell apart two options naming the same booth
+ * through different exhibitors.
+ */
+export interface RouteOption extends AutocompleteOptionObject {
+    exhibitorId?: number;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/esm/store/types.js

@@ -0,0 +1 @@
+export const SESSIONS_LIST_TYPE = 'sessions';