@expofp/floorplan 0.0.0-experimental.2632d13

package/dist/esm/store/providers/SessionsShortcutProvider.js

@@ -0,0 +1,221 @@
+import { __decorate } from "tslib";
+import { computed } from 'mobx';
+import { BaseShortcutProvider } from '../ShortcutProvider';
+export class SessionsShortcutProvider extends BaseShortcutProvider {
+    constructor(rootStore) {
+        super();
+        this.rootStore = rootStore;
+        this.id = 'sessions';
+    }
+    get computedShortcuts() {
+        const { sessionsFilterStore, eventStore } = this.rootStore;
+        const { filters } = sessionsFilterStore.state;
+        const shortcuts = [];
+        shortcuts.push({
+            id: 'bookmarks',
+            icon: 'icon-bookmark',
+            enabled: true,
+            active: filters.showBookmarksOnly.value,
+            tooltip: 'Show bookmarked events only',
+            variant: 'default',
+            action: 'toggle',
+            showResetButton: false,
+        });
+        if (eventStore.tracks.length > 0) {
+            shortcuts.push({
+                id: 'tracks',
+                label: 'Tracks',
+                badge: filters.selectedTracks.value.length > 0 ? filters.selectedTracks.value.length : undefined,
+                enabled: true,
+                active: filters.selectedTracks.value.length > 0,
+                tooltip: 'Show events by tracks',
+                variant: 'default',
+                action: 'custom',
+                showResetButton: true,
+            });
+        }
+        if (this.rootStore.speakerStore.speakers.length > 0) {
+            shortcuts.push({
+                id: 'speakers',
+                label: 'Speakers',
+                enabled: true,
+                active: false,
+                tooltip: 'Open speakers list',
+                variant: 'default',
+                action: 'custom',
+                showResetButton: false,
+            });
+        }
+        // an active Live filter keeps its chip even when nothing is live — a link
+        // or a reload can turn it on, and the chip is the only control that
+        // turns it off
+        if (eventStore.liveEvents.length > 0 || filters.showLiveOnly.value) {
+            shortcuts.push({
+                id: 'live',
+                label: 'Live',
+                enabled: true,
+                active: filters.showLiveOnly.value,
+                tooltip: 'Show events happening now',
+                variant: 'default',
+                action: 'toggle',
+                showResetButton: false,
+            });
+        }
+        if (eventStore.todayEvents.length > 0) {
+            shortcuts.push({
+                id: 'today',
+                label: 'Today',
+                enabled: true,
+                active: filters.date.value === 'today',
+                tooltip: "Show today's events",
+                variant: 'default',
+                action: 'toggle',
+                showResetButton: false,
+            });
+        }
+        if (eventStore.tomorrowEvents.length > 0) {
+            shortcuts.push({
+                id: 'tomorrow',
+                label: 'Tomorrow',
+                enabled: true,
+                active: filters.date.value === 'tomorrow',
+                tooltip: "Show tomorrow's events",
+                variant: 'default',
+                action: 'toggle',
+                showResetButton: false,
+            });
+        }
+        if (eventStore.pastEvents.length > 0) {
+            shortcuts.push({
+                id: 'past',
+                label: 'Past',
+                enabled: true,
+                active: filters.date.value === 'past',
+                tooltip: 'Show past events',
+                variant: 'default',
+                action: 'toggle',
+                showResetButton: false,
+            });
+        }
+        if (eventStore.venues.length > 0) {
+            shortcuts.push({
+                id: 'venues',
+                label: 'Venues',
+                badge: filters.selectedVenues.value.length > 0 ? filters.selectedVenues.value.length : undefined,
+                enabled: true,
+                active: filters.selectedVenues.value.length > 0,
+                tooltip: 'Show events by venues',
+                variant: 'default',
+                action: 'custom',
+                showResetButton: true,
+            });
+        }
+        return shortcuts;
+    }
+    createShortcuts() {
+        return this.computedShortcuts;
+    }
+    handleShortcutClick(shortcutId) {
+        switch (shortcutId) {
+            case 'live':
+                this.toggleLiveFilter();
+                break;
+            case 'bookmarks':
+                this.toggleBookmarksFilter();
+                break;
+            case 'tracks':
+                this.rootStore.sessionsFilterStore.openFilterWithSections(['tracks']);
+                break;
+            case 'venues':
+                this.rootStore.sessionsFilterStore.openFilterWithSections(['venues']);
+                break;
+            case 'speakers':
+                this.rootStore.selectSpeakers();
+                break;
+            case 'today':
+                this.toggleDateFilter('today');
+                break;
+            case 'tomorrow':
+                this.toggleDateFilter('tomorrow');
+                break;
+            case 'past':
+                this.toggleDateFilter('past');
+                break;
+            case 'earliest':
+                this.toggleSortOrder();
+                break;
+            default:
+                console.warn(`Unknown shortcut ID: ${shortcutId}`);
+        }
+    }
+    handleShortcutReset(shortcutId) {
+        const { sessionsFilterStore } = this.rootStore;
+        switch (shortcutId) {
+            case 'live':
+                sessionsFilterStore.setPending('showLiveOnly', false);
+                sessionsFilterStore.applyFilters();
+                break;
+            case 'tracks':
+                sessionsFilterStore.setPending('selectedTracks', []);
+                sessionsFilterStore.applyFilters();
+                break;
+            case 'venues':
+                sessionsFilterStore.setPending('selectedVenues', []);
+                sessionsFilterStore.applyFilters();
+                break;
+            case 'bookmarks':
+                sessionsFilterStore.setPending('showBookmarksOnly', false);
+                sessionsFilterStore.applyFilters();
+                break;
+            case 'today':
+                sessionsFilterStore.setPending('date', 'all');
+                sessionsFilterStore.applyFilters();
+                break;
+            case 'tomorrow':
+                sessionsFilterStore.setPending('date', 'all');
+                sessionsFilterStore.applyFilters();
+                break;
+            case 'past':
+                sessionsFilterStore.setPending('date', 'all');
+                sessionsFilterStore.applyFilters();
+                break;
+            default:
+                console.warn(`Unknown shortcut reset ID: ${shortcutId}`);
+        }
+    }
+    shouldShowShortcuts() {
+        return (this.rootStore.uiState.list.type === 'sessions' && this.rootStore.uiState.details === null);
+    }
+    toggleBookmarksFilter() {
+        const { sessionsFilterStore } = this.rootStore;
+        const newValue = !sessionsFilterStore.state.filters.showBookmarksOnly.value;
+        sessionsFilterStore.setPending('showBookmarksOnly', newValue);
+        sessionsFilterStore.applyFilters();
+    }
+    toggleLiveFilter() {
+        const { sessionsFilterStore } = this.rootStore;
+        const newValue = !sessionsFilterStore.state.filters.showLiveOnly.value;
+        sessionsFilterStore.setPending('showLiveOnly', newValue);
+        sessionsFilterStore.applyFilters();
+    }
+    toggleDateFilter(date) {
+        const { sessionsFilterStore } = this.rootStore;
+        const currentDate = sessionsFilterStore.state.filters.date.value;
+        if (currentDate === date) {
+            sessionsFilterStore.setPending('date', 'all');
+        }
+        else {
+            sessionsFilterStore.setPending('date', date);
+        }
+        sessionsFilterStore.applyFilters();
+    }
+    toggleSortOrder() {
+        const { sessionsFilterStore } = this.rootStore;
+        const newSort = sessionsFilterStore.state.filters.sortOrder.value === 'asc' ? 'desc' : 'asc';
+        sessionsFilterStore.setPending('sortOrder', newSort);
+        sessionsFilterStore.applyFilters();
+    }
+}
+__decorate([
+    computed
+], SessionsShortcutProvider.prototype, "computedShortcuts", null);

package/dist/esm/store/providers/SessionsSubButtonProvider.d.ts

@@ -0,0 +1,33 @@
+import type RootStore from '../RootStore';
+import { BaseSubButtonProvider } from '../SubButtonProvider';
+import { type SearchSubButtonConfig } from '../types';
+export declare class SessionsSubButtonProvider extends BaseSubButtonProvider {
+    private rootStore;
+    readonly id = "sessions";
+    constructor(rootStore: RootStore);
+    private get computedSubButtons();
+    createSubButtons(): SearchSubButtonConfig[];
+    handleSubButtonClick(subButtonId: string): void;
+    shouldShowSubButtons(): boolean;
+    /**
+     * Reports a sub-button click to stats. Must run BEFORE the handler mutates
+     * state, because it compares against the sub-button currently selected — a
+     * click on the one already selected is not a new view of it. (The store's
+     * `handleSubButtonClick` guards the same case the same way, but the UI calls
+     * the `onClick` baked into each config and never reaches that guard.)
+     *
+     * Deliberately NOT the button's own `active`: `sessions_show_all` is also
+     * active whenever no sub-button and no track are selected — the state every
+     * path that opens the sessions list leaves behind — which made the first
+     * "All Tracks" click, the most common one there is, structurally impossible
+     * to report.
+     *
+     * Captions are data (`track.name`) or a plain literal, never `t()`, so the
+     * value is stable across locales. Tagged `subbutton` to keep this row
+     * separable from the main button row.
+     */
+    private reportActivation;
+    private handleSessionsShowAllClick;
+    private handleSessionsTrackClick;
+}
+//# sourceMappingURL=SessionsSubButtonProvider.d.ts.map

package/dist/esm/store/providers/SessionsSubButtonProvider.js

@@ -0,0 +1,100 @@
+import { __decorate } from "tslib";
+import { computed } from 'mobx';
+import trackEvent from '../../tools/track-event';
+import { BaseSubButtonProvider } from '../SubButtonProvider';
+export class SessionsSubButtonProvider extends BaseSubButtonProvider {
+    constructor(rootStore) {
+        super();
+        this.rootStore = rootStore;
+        this.id = 'sessions';
+    }
+    get computedSubButtons() {
+        const subButtons = [];
+        subButtons.push({
+            id: 'sessions_show_all',
+            label: 'All Tracks',
+            text: 'All Tracks',
+            enabled: true,
+            active: this.rootStore.searchButtonsStore.activeSubButtonId === 'sessions_show_all' ||
+                (!this.rootStore.searchButtonsStore.activeSubButtonId &&
+                    !this.rootStore.uiState.selectedTrack),
+            parentButtonId: 'sessions',
+            type: 'show_all',
+            onClick: () => this.handleSessionsShowAllClick(),
+        });
+        this.rootStore.eventStore.tracks.forEach((track) => {
+            const eventsCount = this.rootStore.eventStore.getEventsByTrack(track.id).length;
+            subButtons.push({
+                id: `sessions_track_${track.id}`,
+                label: track.name,
+                text: track.name,
+                enabled: true,
+                active: this.rootStore.searchButtonsStore.activeSubButtonId === `sessions_track_${track.id}`,
+                parentButtonId: 'sessions',
+                type: 'track',
+                data: track,
+                count: eventsCount,
+                onClick: () => this.handleSessionsTrackClick(track),
+            });
+        });
+        return subButtons;
+    }
+    createSubButtons() {
+        return this.computedSubButtons;
+    }
+    handleSubButtonClick(subButtonId) {
+        if (subButtonId === 'sessions_show_all') {
+            this.handleSessionsShowAllClick();
+        }
+        else if (subButtonId.startsWith('sessions_track_')) {
+            const trackId = parseInt(subButtonId.replace('sessions_track_', ''));
+            const track = this.rootStore.eventStore.tracks.find((t) => t.id === trackId);
+            if (track) {
+                this.handleSessionsTrackClick(track);
+            }
+        }
+    }
+    shouldShowSubButtons() {
+        return this.rootStore.eventStore.tracks.length > 0;
+    }
+    /**
+     * Reports a sub-button click to stats. Must run BEFORE the handler mutates
+     * state, because it compares against the sub-button currently selected — a
+     * click on the one already selected is not a new view of it. (The store's
+     * `handleSubButtonClick` guards the same case the same way, but the UI calls
+     * the `onClick` baked into each config and never reaches that guard.)
+     *
+     * Deliberately NOT the button's own `active`: `sessions_show_all` is also
+     * active whenever no sub-button and no track are selected — the state every
+     * path that opens the sessions list leaves behind — which made the first
+     * "All Tracks" click, the most common one there is, structurally impossible
+     * to report.
+     *
+     * Captions are data (`track.name`) or a plain literal, never `t()`, so the
+     * value is stable across locales. Tagged `subbutton` to keep this row
+     * separable from the main button row.
+     */
+    reportActivation(subButtonId) {
+        if (this.rootStore.searchButtonsStore.activeSubButtonId === subButtonId)
+            return;
+        const subButton = this.computedSubButtons.find((button) => button.id === subButtonId);
+        if (!subButton || !subButton.label)
+            return;
+        trackEvent('sbtnview', subButton.label, 'subbutton');
+    }
+    handleSessionsShowAllClick() {
+        this.reportActivation('sessions_show_all');
+        this.rootStore.uiState.list = { type: 'sessions', text: '', focused: false };
+        this.rootStore.uiState.selectedTrack = null;
+        this.rootStore.searchButtonsStore.setSubButtonId('sessions_show_all');
+    }
+    handleSessionsTrackClick(track) {
+        this.reportActivation(`sessions_track_${track.id}`);
+        this.rootStore.uiState.list = { type: 'sessions', text: '', focused: false };
+        this.rootStore.uiState.selectedTrack = track;
+        this.rootStore.searchButtonsStore.setSubButtonId(`sessions_track_${track.id}`);
+    }
+}
+__decorate([
+    computed
+], SessionsSubButtonProvider.prototype, "computedSubButtons", null);

package/dist/esm/store/providers/SpeakerShortcutProvider.d.ts

@@ -0,0 +1,12 @@
+import RootStore from '../RootStore';
+import { BaseShortcutProvider, ShortcutConfig } from '../ShortcutProvider';
+export declare class SpeakerShortcutProvider extends BaseShortcutProvider {
+    private rootStore;
+    readonly id = "speakers";
+    constructor(rootStore: RootStore);
+    private get computedShortcuts();
+    createShortcuts(): ShortcutConfig[];
+    handleShortcutClick(shortcutId: string): void;
+    handleShortcutReset(shortcutId: string): void;
+}
+//# sourceMappingURL=SpeakerShortcutProvider.d.ts.map

package/dist/esm/store/providers/SpeakerShortcutProvider.js

@@ -0,0 +1,73 @@
+import { __decorate } from "tslib";
+/* eslint-disable @typescript-eslint/consistent-type-imports */
+// @ts-nocheck
+import { computed } from 'mobx';
+import { BaseShortcutProvider } from '../ShortcutProvider';
+export class SpeakerShortcutProvider extends BaseShortcutProvider {
+    constructor(rootStore) {
+        super();
+        this.rootStore = rootStore;
+        this.id = 'speakers';
+    }
+    get computedShortcuts() {
+        const { speakerFilterStore } = this.rootStore;
+        const { filters } = speakerFilterStore.state;
+        const shortcuts = [];
+        // shortcuts.push({
+        //     id: "companies",
+        //     label: "Company",
+        //     badge: filters.selectedCompanies.value.length > 0 ? filters.selectedCompanies.value.length : undefined,
+        //     enabled: true,
+        //     active: filters.selectedCompanies.value.length > 0,
+        //     tooltip: "Filter by companies",
+        //     variant: "default",
+        //     action: "custom",
+        //     showResetButton: true,
+        // });
+        // shortcuts.push({
+        //     id: "jobTitles",
+        //     label: "Job Title",
+        //     badge: filters.selectedJobTitles.value.length > 0 ? filters.selectedJobTitles.value.length : undefined,
+        //     enabled: true,
+        //     active: filters.selectedJobTitles.value.length > 0,
+        //     tooltip: "Filter by job titles",
+        //     variant: "default",
+        //     action: "custom",
+        //     showResetButton: true,
+        // });
+        return shortcuts;
+    }
+    createShortcuts() {
+        return this.computedShortcuts;
+    }
+    handleShortcutClick(shortcutId) {
+        switch (shortcutId) {
+            case 'companies':
+                this.rootStore.speakerFilterStore.openFilterWithSections(['companies']);
+                break;
+            case 'jobTitles':
+                this.rootStore.speakerFilterStore.openFilterWithSections(['jobTitles']);
+                break;
+            default:
+                console.warn(`Unknown shortcut ID: ${shortcutId}`);
+        }
+    }
+    handleShortcutReset(shortcutId) {
+        const { speakerFilterStore } = this.rootStore;
+        switch (shortcutId) {
+            case 'companies':
+                speakerFilterStore.setPending('selectedCompanies', []);
+                speakerFilterStore.applyFilters();
+                break;
+            case 'jobTitles':
+                speakerFilterStore.setPending('selectedJobTitles', []);
+                speakerFilterStore.applyFilters();
+                break;
+            default:
+                console.warn(`Unknown shortcut ID for reset: ${shortcutId}`);
+        }
+    }
+}
+__decorate([
+    computed
+], SpeakerShortcutProvider.prototype, "computedShortcuts", null);

package/dist/esm/store/reveal-layer.d.ts

@@ -0,0 +1,29 @@
+/** The slice of a `Layer` this helper needs: an observable `visible` flag. */
+export interface RevealableLayer {
+    readonly visible: boolean;
+}
+export interface RevealLayerArgs<L extends RevealableLayer> {
+    /** The floor the target sits on; `null`/`undefined` when the plan has no floors or the floor is unknown. */
+    readonly layer: L | null | undefined;
+    /** Switches the floor on (`LayerStore.updateVisibility(layer, true)`); its effect lands asynchronously. */
+    readonly show: (layer: L) => void;
+    /** The camera move to run once the floor is on screen. */
+    readonly then: () => void;
+}
+/**
+ * Brings a target's floor on screen, then runs the camera move.
+ *
+ * - no floor, or floor already visible → the move runs right away;
+ * - otherwise the floor is switched on and the move waits for `visible` to
+ *   actually flip — `LayerStore.updateVisibility` resolves that after the layer
+ *   payload loads, so a move issued synchronously would either frame the old
+ *   floor (legacy renderer) or be superseded by the floor-change fit the
+ *   MapLibre adapter performs when the visible floor changes
+ *   (`useLayerVisibilitySync`). Deferring the move behind the same `visible`
+ *   flip makes it the *last* camera command of that change, so it wins.
+ *
+ * Returns a disposer for the pending wait (no-op once the move has run) —
+ * callers cancel a previous reveal before starting a new one.
+ */
+export declare function revealLayer<L extends RevealableLayer>({ layer, show, then, }: RevealLayerArgs<L>): () => void;
+//# sourceMappingURL=reveal-layer.d.ts.map

package/dist/esm/store/reveal-layer.js

@@ -0,0 +1,25 @@
+import { when } from 'mobx';
+const noop = () => undefined;
+/**
+ * Brings a target's floor on screen, then runs the camera move.
+ *
+ * - no floor, or floor already visible → the move runs right away;
+ * - otherwise the floor is switched on and the move waits for `visible` to
+ *   actually flip — `LayerStore.updateVisibility` resolves that after the layer
+ *   payload loads, so a move issued synchronously would either frame the old
+ *   floor (legacy renderer) or be superseded by the floor-change fit the
+ *   MapLibre adapter performs when the visible floor changes
+ *   (`useLayerVisibilitySync`). Deferring the move behind the same `visible`
+ *   flip makes it the *last* camera command of that change, so it wins.
+ *
+ * Returns a disposer for the pending wait (no-op once the move has run) —
+ * callers cancel a previous reveal before starting a new one.
+ */
+export function revealLayer({ layer, show, then, }) {
+    if (!layer || layer.visible) {
+        then();
+        return noop;
+    }
+    show(layer);
+    return when(() => layer.visible, then);
+}

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

@@ -0,0 +1,55 @@
+import type RootStore from '../RootStore';
+import { type SearchButtonsFilters } from './SearchButtonsFilters';
+import { type SearchButtonsState } from './SearchButtonsState';
+export declare class SearchButtonsActions {
+    private rootStore;
+    private state;
+    private filters;
+    constructor(rootStore: RootStore, state: SearchButtonsState, filters: SearchButtonsFilters);
+    /**
+     * 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.
+     */
+    private reportActivation;
+    handleSearchButtonClick(searchButtonId: string, caption?: string): void;
+    handleExtendedSearchButtonClick(buttonId: string): void;
+    handleMainButtonClick(buttonId: string): void;
+    handleSessionsClick(caption?: string): void;
+    togglePoiType(poiTypeId: number): void;
+    clearAllFilters(): void;
+    /**
+     * 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(): void;
+    showSubButtons(parentButtonId: string): void;
+    hideSubButtons(): void;
+    handleSubButtonClick(subButtonId: string): void;
+    private toggleListView;
+    private handleBookmarksClick;
+    private handleVisitedClick;
+    private handleToursClick;
+    private handleCategoriesClick;
+    private handleExhibitorsClick;
+    private handlePoiTypeClick;
+    private handleLinkClick;
+    private handleParentButton;
+    private preserveSearchText;
+    private switchToSearch;
+    private resetAllFilters;
+    /** Turns off the active search button and every filter it applied, URL included. */
+    private clearActiveFilters;
+    private setPoiFilterFromString;
+    private get isMobile();
+}
+//# sourceMappingURL=SearchButtonsActions.d.ts.map