@expofp/floorplan 0.0.0-experimental.2632d13

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

@@ -0,0 +1,363 @@
+import { __decorate } from "tslib";
+import { action } from 'mobx';
+import { MOBILE_BREAKPOINT } from '../../constants';
+import trackEvent from '../../tools/track-event';
+import { PREFIXES, SearchButtonType } from './constants';
+import { extractPoiTypeId, getButtonConfig } from './utils';
+export class SearchButtonsActions {
+    constructor(rootStore, state, filters) {
+        this.rootStore = rootStore;
+        this.state = state;
+        this.filters = filters;
+    }
+    /**
+     * Reports a search-button click to stats. Called only from the branch of a
+     * handler that turns the button ON: the click that switches a filter off is
+     * not a view of it. Deriving that from the button's `active` prop instead
+     * would be wrong — `active` is a display flag whose meaning differs per
+     * button (for Categories it means "filters are applied", not "panel open"),
+     * so only the handler knows what its own click did.
+     *
+     * `caption` is the button's configured name, NOT the rendered label: the
+     * label is run through `tIfExists`, so reporting it would split one button
+     * into one analytics series per locale.
+     */
+    reportActivation(caption) {
+        if (caption)
+            trackEvent('sbtnview', caption);
+    }
+    handleSearchButtonClick(searchButtonId, caption) {
+        const handlers = {
+            [SearchButtonType.BOOKMARKS]: () => this.handleBookmarksClick(caption),
+            [SearchButtonType.VISITED]: () => this.handleVisitedClick(caption),
+            [SearchButtonType.SESSIONS]: () => this.handleSessionsClick(caption),
+            [SearchButtonType.TOURS]: () => this.handleToursClick(caption),
+            [SearchButtonType.CATEGORIES]: () => this.handleCategoriesClick(caption),
+            [SearchButtonType.EXHIBITORS]: () => this.handleExhibitorsClick(caption),
+        };
+        const handler = handlers[searchButtonId];
+        if (handler) {
+            handler();
+            return;
+        }
+        if (searchButtonId.startsWith(PREFIXES.POI_TYPE)) {
+            this.handlePoiTypeClick(searchButtonId, caption);
+        }
+    }
+    handleExtendedSearchButtonClick(buttonId) {
+        const buttonConfig = getButtonConfig(buttonId);
+        if (!buttonConfig)
+            return;
+        const caption = buttonConfig.name;
+        if (buttonConfig.type === 'link') {
+            this.handleLinkClick(buttonConfig, caption);
+            return;
+        }
+        const visibleChildren = buttonConfig.children?.filter((child) => child.visible) || [];
+        if (visibleChildren.length === 1 &&
+            visibleChildren[0].type === 'poi_types' &&
+            visibleChildren[0].name === buttonConfig.name) {
+            this.handleSearchButtonClick(buttonId, caption);
+            return;
+        }
+        if (buttonConfig.children && visibleChildren.length > 0) {
+            this.handleParentButton(buttonId, buttonConfig, caption);
+        }
+        else {
+            this.handleSearchButtonClick(buttonId, caption);
+        }
+    }
+    handleMainButtonClick(buttonId) {
+        this.handleSearchButtonClick(buttonId);
+    }
+    handleSessionsClick(caption) {
+        const { uiState } = this.rootStore;
+        if (uiState.list.type === 'sessions') {
+            this.switchToSearch();
+        }
+        else {
+            this.reportActivation(caption);
+            this.resetAllFilters();
+            uiState.details = null;
+            uiState.menu = false;
+            uiState.list = { type: 'sessions', text: '', focused: false };
+            this.state.setSubButton(null);
+            uiState.selectedTrack = null;
+            if (this.state.subButtonsEnabled) {
+                this.showSubButtons('sessions');
+            }
+            if (this.isMobile) {
+                uiState.desiredOverlaySize = 'full';
+            }
+        }
+    }
+    togglePoiType(poiTypeId) {
+        this.handleSearchButtonClick(`${PREFIXES.POI_TYPE}${poiTypeId}`);
+    }
+    clearAllFilters() {
+        this.switchToSearch();
+    }
+    /**
+     * Turns the active search button off when navigation opens, so its pins do
+     * not crowd the route. Unlike `clearAllFilters` it leaves the panel, the
+     * list and the details alone (they now show the navigation) and keeps
+     * pathways, which belong to tours, not to search buttons.
+     */
+    deactivateForNavigation() {
+        const { uiState } = this.rootStore;
+        const hasActiveFilter = this.state.activePoiFilterId !== null ||
+            this.state.searchShortcutState.activeParentId !== null ||
+            uiState.hasAppliedFilters;
+        if (hasActiveFilter)
+            this.clearActiveFilters();
+    }
+    showSubButtons(parentButtonId) {
+        if (!this.state.subButtonsEnabled)
+            return;
+        this.state.setSubButtonParent(parentButtonId);
+        this.state.setSubButton(null);
+        this.rootStore.uiState.subButtonsVisible = true;
+    }
+    hideSubButtons() {
+        this.state.setSubButtonParent(null);
+        this.state.setSubButton(null);
+        this.rootStore.uiState.subButtonsVisible = false;
+    }
+    handleSubButtonClick(subButtonId) {
+        if (this.state.activeSubButtonId === subButtonId)
+            return;
+        this.state.setSubButton(subButtonId);
+    }
+    toggleListView(type, onActivate, caption) {
+        const isActive = this.rootStore.uiState.list.type === type;
+        if (isActive) {
+            this.switchToSearch();
+        }
+        else {
+            this.reportActivation(caption);
+            this.resetAllFilters();
+            onActivate();
+        }
+    }
+    handleBookmarksClick(caption) {
+        this.toggleListView('bookmarks', () => {
+            this.rootStore.clickBookmarks();
+        }, caption);
+    }
+    handleVisitedClick(caption) {
+        this.toggleListView('visited', () => {
+            this.rootStore.clickVisited();
+        }, caption);
+    }
+    handleToursClick(caption) {
+        const { uiState } = this.rootStore;
+        // only `tours` closes the list — from a multi-point tour this click opens
+        // it, which is an activation and must be reported
+        if (uiState.list.type === 'tours') {
+            this.switchToSearch();
+        }
+        else {
+            this.reportActivation(caption);
+            this.resetAllFilters();
+            uiState.details = null;
+            uiState.menu = false;
+            uiState.list = { type: 'tours', text: '', focused: false };
+            if (this.isMobile) {
+                uiState.desiredOverlaySize = 'full';
+            }
+        }
+    }
+    handleCategoriesClick(caption) {
+        const { uiState } = this.rootStore;
+        // ends in `openFilter()` on every path — the panel opens whether or not
+        // categories are already applied, so every click is an activation
+        this.reportActivation(caption);
+        if (uiState.list.type !== 'search') {
+            this.switchToSearch();
+        }
+        else if (this.state.activePoiFilterId) {
+            this.filters.clearPoiTypeFilters();
+        }
+        if (this.state.searchShortcutState.activeParentId) {
+            this.state.setActiveParentId(null);
+            this.state.clearChildren();
+            this.state.showShortcuts(false);
+            this.filters.clearAllChildFilters();
+        }
+        this.rootStore.categoryFilterStore.openFilter();
+    }
+    handleExhibitorsClick(caption) {
+        const { uiState } = this.rootStore;
+        if (uiState.list.type === 'exhibitors') {
+            this.switchToSearch();
+        }
+        else {
+            this.reportActivation(caption);
+            this.resetAllFilters();
+            uiState.details = null;
+            uiState.menu = false;
+            uiState.list = { type: 'exhibitors', text: '', focused: false };
+            if (this.isMobile) {
+                uiState.desiredOverlaySize = 'full';
+            }
+        }
+    }
+    handlePoiTypeClick(filterId, caption) {
+        const { uiState } = this.rootStore;
+        // Decided once, up front: `switchToSearch(true)` below runs
+        // `resetAllFilters()`, which nulls `activePoiFilterId`. Reading the field
+        // again afterwards made the toggle re-activate a filter that was already
+        // on, and disagree with this guard about whether anything had happened.
+        const willActivate = this.state.activePoiFilterId !== filterId;
+        if (willActivate)
+            this.reportActivation(caption);
+        const currentSearchText = uiState.list.type === 'search' ? uiState.list.text || '' : '';
+        if (uiState.list.type !== 'search') {
+            this.switchToSearch(true);
+        }
+        else if (uiState.selectedCategoryFilters.length > 0) {
+            this.filters.clearCategoryFilters();
+        }
+        if (this.state.searchShortcutState.activeParentId) {
+            this.state.setActiveParentId(null);
+            this.state.clearChildren();
+            this.state.showShortcuts(false);
+            this.filters.clearAllChildFilters();
+        }
+        if (willActivate) {
+            this.setPoiFilterFromString(filterId);
+        }
+        else {
+            this.filters.clearPoiTypeFilters();
+        }
+        if (currentSearchText && uiState.list.type === 'search') {
+            uiState.list = {
+                type: 'search',
+                text: currentSearchText,
+                focused: false,
+            };
+        }
+        this.rootStore.searchStore.selectSearchAndFocus(currentSearchText);
+    }
+    handleLinkClick(buttonConfig, caption) {
+        const linkChild = buttonConfig.children?.find((child) => child.type === 'link');
+        if (linkChild && 'linkUrl' in linkChild) {
+            // Reported from inside the branch that acts, like every other handler
+            // here: a `link` button configured without a usable link child opens
+            // nothing, and must not inflate its own view counter.
+            this.reportActivation(caption);
+            window.open(linkChild.linkUrl, '_blank');
+        }
+    }
+    handleParentButton(buttonId, buttonConfig, caption) {
+        const { uiState } = this.rootStore;
+        if (this.state.searchShortcutState.activeParentId === buttonId) {
+            this.state.setActiveParentId(null);
+            this.state.clearChildren();
+            this.state.showShortcuts(false);
+            this.filters.clearAllChildFilters();
+            this.rootStore.urlFilterManager.clearAllFilters();
+            uiState.centerMap = true;
+            if (uiState.overlaySize === 'full' && uiState.searchFocused) {
+                this.rootStore.searchStore.setFocused(false);
+            }
+            return;
+        }
+        this.reportActivation(caption);
+        if (uiState.list.type !== 'search') {
+            this.switchToSearch();
+        }
+        if (this.state.activePoiFilterId) {
+            this.state.setPoiFilter(null);
+        }
+        this.state.setActiveParentId(buttonId);
+        this.state.showShortcuts(true);
+        this.state.clearChildren();
+        this.filters.applyAllChildrenFilters(buttonConfig);
+        this.rootStore.searchStore.selectSearchAndFocus();
+    }
+    preserveSearchText(callback) {
+        const { uiState } = this.rootStore;
+        const currentText = uiState.list.type === 'search' ? uiState.list.text || '' : '';
+        callback();
+        if (uiState.list.type === 'search' && currentText) {
+            uiState.list = {
+                type: 'search',
+                text: currentText,
+                focused: false,
+            };
+        }
+    }
+    switchToSearch(preserveText = false) {
+        const resetAndSwitch = () => {
+            this.resetAllFilters();
+            this.rootStore.uiState.details = null;
+            this.rootStore.uiState.menu = false;
+            this.rootStore.uiState.list = { type: 'search', text: '', focused: false };
+        };
+        if (preserveText) {
+            this.preserveSearchText(resetAndSwitch);
+        }
+        else {
+            resetAndSwitch();
+        }
+    }
+    resetAllFilters() {
+        this.clearActiveFilters();
+        this.rootStore.fp.hidePathways();
+    }
+    /** Turns off the active search button and every filter it applied, URL included. */
+    clearActiveFilters() {
+        this.state.reset();
+        this.rootStore.uiState.selectedPoiTypeFilters = [];
+        this.rootStore.uiState.selectedCategoryFilters = [];
+        this.rootStore.uiState.categoryFilterOpen = false;
+        this.rootStore.categoryFilterStore.state.selectedItems = [];
+        this.rootStore.categoryFilterStore.state.pendingItems = [];
+        this.rootStore.urlFilterManager.clearAllFilters();
+    }
+    setPoiFilterFromString(filterId) {
+        this.state.setPoiFilter(filterId);
+        const poiTypeId = extractPoiTypeId(filterId);
+        if (poiTypeId !== null) {
+            const poiType = this.rootStore.poiTypeStore.poiTypes.find((pt) => pt.id === poiTypeId);
+            if (poiType) {
+                this.rootStore.uiState.selectedPoiTypeFilters = [poiType];
+                this.rootStore.urlFilterManager.setPoiType(poiType.name);
+            }
+        }
+    }
+    get isMobile() {
+        return typeof window !== 'undefined' && window.innerWidth <= MOBILE_BREAKPOINT;
+    }
+}
+__decorate([
+    action
+], SearchButtonsActions.prototype, "handleSearchButtonClick", null);
+__decorate([
+    action
+], SearchButtonsActions.prototype, "handleExtendedSearchButtonClick", null);
+__decorate([
+    action
+], SearchButtonsActions.prototype, "handleMainButtonClick", null);
+__decorate([
+    action
+], SearchButtonsActions.prototype, "handleSessionsClick", null);
+__decorate([
+    action
+], SearchButtonsActions.prototype, "togglePoiType", null);
+__decorate([
+    action
+], SearchButtonsActions.prototype, "clearAllFilters", null);
+__decorate([
+    action
+], SearchButtonsActions.prototype, "deactivateForNavigation", null);
+__decorate([
+    action
+], SearchButtonsActions.prototype, "showSubButtons", null);
+__decorate([
+    action
+], SearchButtonsActions.prototype, "hideSubButtons", null);
+__decorate([
+    action
+], SearchButtonsActions.prototype, "handleSubButtonClick", null);

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

@@ -0,0 +1,37 @@
+import type RootStore from '../RootStore';
+import { type SearchButtonConfig, type SearchButtonTypeConfig } from '../types';
+import { type SearchButtonsActions } from './SearchButtonsActions';
+import { type SearchButtonsState } from './SearchButtonsState';
+export declare class SearchButtonsFactory {
+    private rootStore;
+    private state;
+    private actions;
+    private readonly buttonFactories;
+    constructor(rootStore: RootStore, state: SearchButtonsState, actions: SearchButtonsActions);
+    createButtons(configs: SearchButtonTypeConfig[]): SearchButtonConfig[];
+    private createButton;
+    private createBaseButton;
+    private createButtonId;
+    private createBookmarksButton;
+    private createVisitedButton;
+    private createCategoriesButton;
+    private createSimpleCategoriesButton;
+    private createSessionsButton;
+    private createGuidedToursButton;
+    private createPoiTypeButton;
+    private createPoiTypesButton;
+    private shouldFlattenToSinglePoiType;
+    private createLinkButton;
+    private createExhibitorsButton;
+    private countCategories;
+    private countPoiTypes;
+    private dedupeButtons;
+    private countBookmarks;
+    private countVisited;
+    private getSessionsTotalCount;
+    private getGuidedToursTotalCount;
+    private getCategoriesTotalCount;
+    private getPoiTypeTotalCount;
+    private getExhibitorsTotalCount;
+}
+//# sourceMappingURL=SearchButtonsFactory.d.ts.map

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

@@ -0,0 +1,291 @@
+import data from '../../data';
+import { getContrastTextColor } from '../../utils/getContrastTextColor';
+import { tIfExists } from '../../utils/i18n';
+import { BUTTON_ICONS, PREFIXES, SearchButtonType } from './constants';
+export class SearchButtonsFactory {
+    constructor(rootStore, state, actions) {
+        this.rootStore = rootStore;
+        this.state = state;
+        this.actions = actions;
+        this.buttonFactories = {
+            [SearchButtonType.BOOKMARKS]: (c) => this.createBookmarksButton(c),
+            [SearchButtonType.VISITED]: (c) => this.createVisitedButton(c),
+            [SearchButtonType.CATEGORIES]: (c) => this.createCategoriesButton(c),
+            [SearchButtonType.SESSIONS]: (c) => this.createSessionsButton(c),
+            [SearchButtonType.TOURS]: (c) => this.createGuidedToursButton(c),
+            [SearchButtonType.POI_TYPE]: (c) => this.createPoiTypeButton(c),
+            [SearchButtonType.POI_TYPES]: (c) => this.createPoiTypesButton(c),
+            [SearchButtonType.LINK]: (c) => this.createLinkButton(c),
+            [SearchButtonType.EXHIBITORS]: (c) => this.createExhibitorsButton(c),
+        };
+    }
+    createButtons(configs) {
+        return this.dedupeButtons(configs)
+            .filter((btn) => btn.visible)
+            .map((btn) => ({
+            button: this.createButton(btn),
+            order: btn.order ?? Number.MAX_SAFE_INTEGER,
+        }))
+            .filter((item) => item.button !== null)
+            .sort((a, b) => a.order - b.order)
+            .map((item) => item.button);
+    }
+    createButton(config) {
+        const factory = this.buttonFactories[config.type];
+        return factory ? factory(config) : null;
+    }
+    createBaseButton(config) {
+        const hasCustomColor = config.color && config.color.toUpperCase() !== '#FFFFFF';
+        // `label`/`text` are localized for display; stats get `config.name` (see
+        // the `onClick` handlers below), which is the same caption in one stable
+        // form across all locales.
+        const label = tIfExists(config.name);
+        return {
+            id: config.id || `${config.type}_${config.name}`,
+            label,
+            text: label,
+            enabled: true,
+            isDimmed: false,
+            isClickable: true,
+            backgroundColor: hasCustomColor ? config.color : undefined,
+            textColor: hasCustomColor && config.color ? getContrastTextColor(config.color) : undefined,
+        };
+    }
+    createButtonId(prefix, config) {
+        return config.id || `${prefix}${config.name}`;
+    }
+    createBookmarksButton(config) {
+        const { uiState } = this.rootStore;
+        if (uiState.kiosk || uiState.disableBookmarked || data.hideBookmarks) {
+            return null;
+        }
+        return {
+            ...this.createBaseButton(config),
+            id: SearchButtonType.BOOKMARKS,
+            icon: BUTTON_ICONS.BOOKMARKS,
+            active: uiState.list.type === 'bookmarks',
+            count: this.countBookmarks(),
+            onClick: () => this.actions.handleSearchButtonClick(SearchButtonType.BOOKMARKS, config.name),
+        };
+    }
+    createVisitedButton(config) {
+        const { uiState } = this.rootStore;
+        if (uiState.kiosk) {
+            return null;
+        }
+        return {
+            ...this.createBaseButton(config),
+            id: SearchButtonType.VISITED,
+            icon: BUTTON_ICONS.VISITED,
+            active: uiState.list.type === 'visited',
+            count: this.countVisited(),
+            onClick: () => this.actions.handleSearchButtonClick(SearchButtonType.VISITED, config.name),
+        };
+    }
+    createCategoriesButton(config) {
+        if (!config.children?.length) {
+            const totalCount = this.getCategoriesTotalCount();
+            return totalCount > 0 ? this.createSimpleCategoriesButton(config, totalCount) : null;
+        }
+        const visibleChildren = (config.children || []).filter((child) => child.visible);
+        if (visibleChildren.length === 0) {
+            return null;
+        }
+        const buttonId = this.createButtonId(PREFIXES.CATEGORIES, config);
+        const categoryChildren = visibleChildren.filter((child) => child.type === 'categories');
+        const count = this.countCategories(categoryChildren);
+        return {
+            ...this.createBaseButton(config),
+            id: buttonId,
+            active: this.state.searchShortcutState.activeParentId === buttonId,
+            count,
+            showZeroCount: true,
+            onClick: () => this.actions.handleExtendedSearchButtonClick(buttonId),
+        };
+    }
+    createSimpleCategoriesButton(config, totalCount) {
+        const { uiState } = this.rootStore;
+        const count = uiState.selectedCategoryFilters.length > 0
+            ? uiState.selectedCategoryFilters.length
+            : totalCount;
+        return {
+            ...this.createBaseButton(config),
+            id: SearchButtonType.CATEGORIES,
+            active: uiState.selectedCategoryFilters.length > 0 &&
+                !this.state.searchShortcutState.activeParentId,
+            count,
+            showZeroCount: true,
+            onClick: () => this.actions.handleSearchButtonClick(SearchButtonType.CATEGORIES, config.name),
+        };
+    }
+    createSessionsButton(config) {
+        const { uiState } = this.rootStore;
+        const totalCount = this.getSessionsTotalCount();
+        if (totalCount === 0) {
+            return null;
+        }
+        return {
+            ...this.createBaseButton(config),
+            id: SearchButtonType.SESSIONS,
+            icon: BUTTON_ICONS.SESSIONS,
+            active: uiState.list.type === 'sessions',
+            count: totalCount,
+            showZeroCount: true,
+            hasSubButtons: true,
+            onClick: () => this.actions.handleSessionsClick(config.name),
+        };
+    }
+    createGuidedToursButton(config) {
+        const { uiState } = this.rootStore;
+        const totalCount = this.getGuidedToursTotalCount();
+        if (totalCount === 0) {
+            return null;
+        }
+        return {
+            ...this.createBaseButton(config),
+            id: 'guided_tours',
+            active: uiState.list.type === 'tours' || uiState.list.type === 'multi-point-tour',
+            count: totalCount,
+            showZeroCount: true,
+            onClick: () => this.actions.handleSearchButtonClick('guided_tours', config.name),
+        };
+    }
+    createPoiTypeButton(config) {
+        const poiType = this.rootStore.poiTypeStore.poiTypes.find((pt) => pt.name === config.name);
+        if (!poiType) {
+            return null;
+        }
+        const filterId = `${PREFIXES.POI_TYPE}${poiType.id}`;
+        const count = this.getPoiTypeTotalCount(poiType.id);
+        if (count === 0) {
+            return null;
+        }
+        return {
+            ...this.createBaseButton(config),
+            id: filterId,
+            active: this.state.activePoiFilterId === filterId,
+            count,
+            showZeroCount: true,
+            onClick: () => this.actions.handleSearchButtonClick(filterId, config.name),
+        };
+    }
+    createPoiTypesButton(config) {
+        if (!config.children?.length) {
+            return this.createPoiTypeButton(config);
+        }
+        const visibleChildren = config.children.filter((child) => child.visible);
+        if (visibleChildren.length === 0) {
+            return null;
+        }
+        if (this.shouldFlattenToSinglePoiType(visibleChildren, config)) {
+            return this.createPoiTypeButton(config);
+        }
+        const filterableChildren = visibleChildren.filter((child) => child.type !== 'link');
+        const totalCount = this.countPoiTypes(filterableChildren);
+        const buttonId = this.createButtonId(PREFIXES.POI_TYPES, config);
+        return {
+            ...this.createBaseButton(config),
+            id: buttonId,
+            active: this.state.searchShortcutState.activeParentId === buttonId,
+            count: totalCount,
+            showZeroCount: true,
+            onClick: () => this.actions.handleExtendedSearchButtonClick(buttonId),
+        };
+    }
+    shouldFlattenToSinglePoiType(visibleChildren, config) {
+        return (visibleChildren.length === 1 &&
+            visibleChildren[0].type === 'poi_types' &&
+            visibleChildren[0].name === config.name);
+    }
+    createLinkButton(config) {
+        const buttonId = this.createButtonId(PREFIXES.LINK, config);
+        return {
+            ...this.createBaseButton(config),
+            id: buttonId,
+            active: false,
+            onClick: () => this.actions.handleExtendedSearchButtonClick(buttonId),
+        };
+    }
+    createExhibitorsButton(config) {
+        const { uiState } = this.rootStore;
+        const totalCount = this.getExhibitorsTotalCount();
+        if (totalCount === 0) {
+            return null;
+        }
+        return {
+            ...this.createBaseButton(config),
+            id: SearchButtonType.EXHIBITORS,
+            icon: BUTTON_ICONS.EXHIBITORS,
+            active: uiState.list.type === 'exhibitors',
+            count: totalCount,
+            showZeroCount: true,
+            onClick: () => this.actions.handleSearchButtonClick(SearchButtonType.EXHIBITORS, config.name),
+        };
+    }
+    countCategories(children) {
+        const { categoryById } = this.rootStore.categoryStore;
+        const exhibitorIds = new Set();
+        children.forEach((child) => {
+            if (child.type !== 'categories') {
+                return;
+            }
+            const category = categoryById.get(Number(child.id));
+            if (category) {
+                category.exhibitors.forEach((exhibitor) => exhibitorIds.add(exhibitor.id));
+            }
+        });
+        return exhibitorIds.size;
+    }
+    countPoiTypes(children) {
+        return children.reduce((sum, child) => {
+            if (child.type !== 'poi_types') {
+                return sum;
+            }
+            if (child.count !== undefined) {
+                return sum + child.count;
+            }
+            const childNumericId = Number(child.id);
+            const poiType = this.rootStore.poiTypeStore.poiTypes.find((p) => p.id === childNumericId);
+            if (poiType) {
+                const boothCount = this.rootStore.boothStore.booths.filter((b) => b.poiTypeId === poiType.id).length;
+                return sum + boothCount;
+            }
+            return sum;
+        }, 0);
+    }
+    dedupeButtons(buttons) {
+        const seen = new Set();
+        return buttons.filter((button) => {
+            const key = `${button.type}_${button.name}`;
+            if (seen.has(key)) {
+                return false;
+            }
+            seen.add(key);
+            return true;
+        });
+    }
+    countBookmarks() {
+        return (this.rootStore.exhibitorStore.bookmarked.length +
+            this.rootStore.eventStore.bookmarked.length +
+            this.rootStore.speakerStore.bookmarked.length +
+            this.rootStore.boothStore.booths.filter((b) => b.exhibitors.length === 0 && b.bookmarkedDirectly).length);
+    }
+    countVisited() {
+        return this.rootStore.exhibitorStore.visited.length + this.rootStore.eventStore.visited.length;
+    }
+    getSessionsTotalCount() {
+        return this.rootStore.eventStore.eventItems.length;
+    }
+    getGuidedToursTotalCount() {
+        return this.rootStore.toursStore.hasTours ? this.rootStore.toursStore.tourItems.length : 0;
+    }
+    getCategoriesTotalCount() {
+        return this.rootStore.categoryStore.categories.filter((category) => category.exhibitors.length > 0).length;
+    }
+    getPoiTypeTotalCount(poiTypeId) {
+        return this.rootStore.boothStore.booths.filter((booth) => booth.poiTypeId === poiTypeId).length;
+    }
+    getExhibitorsTotalCount() {
+        return this.rootStore.exhibitorStore.exhibitors.length;
+    }
+}