@expofp/floorplan 0.0.0-experimental.2d6c681

package/dist/esm/services/URLFilterManager.js

@@ -0,0 +1,379 @@
+import { __decorate } from "tslib";
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { getConfig } from '@expofp/config';
+import { action, observable } from 'mobx';
+import { PREFIXES } from '../store/search-buttons/constants';
+import logger from '../tools/logger';
+import { planReaction } from '../utils/plan-reactions.js';
+import { decodeString, decodeStringArray, encodeString, encodeStringArray, toLowerCaseArray, toLowerCaseString, } from '../utils/urlEncoding';
+import { replaceQuery } from './url-sync';
+const URL_PARAMS = {
+    CATEGORIES: 'categories',
+    POI_TYPE: 'poiType',
+    POI_TYPES: 'poiTypes',
+    EXHIBITORS: 'exhibitors',
+};
+export class URLFilterManager {
+    constructor(rootStore) {
+        this.rootStore = rootStore;
+        this.currentFilters = {
+            categories: [],
+            poiType: null,
+            poiTypes: [],
+            exhibitors: false,
+        };
+        this.isInitialized = false;
+        this.setupReactions();
+    }
+    initialize() {
+        this.parseURLFilters();
+        this.applyFiltersToStore();
+        this.isInitialized = true;
+        logger.log('URLFilterManager initialized with filters:', this.currentFilters);
+    }
+    parseURLFilters() {
+        const { categories, poiType, poiTypes, exhibitors } = this.readRawFilters();
+        const validPoiTypes = poiTypes.filter((name) => {
+            if (!name)
+                return false;
+            const poiTypeExists = this.rootStore.poiTypeStore.poiTypes.some((pt) => pt.name.toLowerCase() === name.toLowerCase());
+            if (!poiTypeExists) {
+                logger.warn(`POI type not found in data: ${name}`);
+            }
+            return poiTypeExists;
+        });
+        if (categories.length > 0 && (poiType || validPoiTypes.length > 0)) {
+            logger.warn('URL contains both categories and POI types. Clearing POI types.');
+            this.currentFilters = {
+                categories,
+                poiType: null,
+                poiTypes: [],
+                exhibitors,
+            };
+        }
+        else {
+            this.currentFilters = { categories, poiType, poiTypes: validPoiTypes, exhibitors };
+        }
+        logger.log('URLFilterManager parsed filters:', { categories, poiType, poiTypes, exhibitors });
+        this.validateFilters(this.currentFilters);
+    }
+    /**
+     * The raw filter values, before catalog validation. The canonical
+     * `config.filters` node wins when present (`?filters[categories][0]=food` or
+     * any config layer; values are plain names, no custom decoding).
+     */
+    readRawFilters() {
+        const filters = getConfig().filters;
+        if (Object.keys(filters).length > 0) {
+            return {
+                // own copies: currentFilters is deeply observable and the config is frozen
+                categories: [...(filters.categories ?? [])],
+                poiType: filters.poiType ?? null,
+                poiTypes: [...(filters.poiTypes ?? [])],
+                exhibitors: filters.exhibitors ?? false,
+            };
+        }
+        // legacy keys stay raw-read here: their values use the legacy string
+        // encoding and the keys must survive in the URL — see the retirement
+        // plan §4.9
+        const urlParams = new URLSearchParams(window.location.search);
+        const categoriesParam = urlParams.get(URL_PARAMS.CATEGORIES);
+        const categories = categoriesParam ? decodeStringArray(categoriesParam) : [];
+        const poiTypeParam = urlParams.get(URL_PARAMS.POI_TYPE);
+        const poiType = poiTypeParam ? decodeString(poiTypeParam) : null;
+        const poiTypesParam = urlParams.get(URL_PARAMS.POI_TYPES);
+        const poiTypes = poiTypesParam ? decodeStringArray(poiTypesParam) : [];
+        const exhibitorsParam = urlParams.get(URL_PARAMS.EXHIBITORS);
+        const exhibitors = exhibitorsParam === 'true' || exhibitorsParam === '';
+        return { categories, poiType, poiTypes, exhibitors };
+    }
+    applyFiltersToStore() {
+        const { uiState, categoryFilterStore, searchButtonsStore } = this.rootStore;
+        if (this.currentFilters.categories.length > 0) {
+            const selectedCategories = this.currentFilters.categories
+                .map((name) => this.rootStore.categoryStore.categories.find((cat) => cat.name.toLowerCase() === name.toLowerCase()))
+                .filter((cat) => cat !== undefined);
+            if (selectedCategories.length > 0) {
+                uiState.selectedCategoryFilters = selectedCategories;
+                categoryFilterStore.state.selectedItems = selectedCategories.map((cat) => ({
+                    id: cat.id,
+                    name: cat.name,
+                }));
+                uiState.categoryFilterOpen = true;
+                logger.log('URLFilterManager applied categories:', selectedCategories.map((cat) => cat.name));
+                setTimeout(() => {
+                    this.focusOnFilteredBooths();
+                    this.rootStore.searchStore.setFocused(true);
+                }, 100);
+            }
+            else {
+                logger.warn('URLFilterManager: no categories found for names:', this.currentFilters.categories);
+            }
+        }
+        if (this.currentFilters.poiType) {
+            const selectedPoiType = this.rootStore.poiTypeStore.poiTypes.find((pt) => pt.name.toLowerCase() === this.currentFilters.poiType.toLowerCase());
+            if (selectedPoiType) {
+                uiState.selectedPoiTypeFilters = [selectedPoiType];
+                searchButtonsStore.setPoiFilterId(`${PREFIXES.POI_TYPE}${selectedPoiType.id}`);
+                logger.log('URLFilterManager applied POI type:', selectedPoiType.name);
+                setTimeout(() => {
+                    this.focusOnFilteredBooths();
+                    this.rootStore.searchStore.setFocused(true);
+                }, 100);
+            }
+            else {
+                logger.warn('URLFilterManager: no POI type found for name:', this.currentFilters.poiType);
+            }
+        }
+        if (this.currentFilters.poiTypes.length > 0) {
+            const selectedPoiTypes = this.currentFilters.poiTypes
+                .map((name) => {
+                if (!name)
+                    return null;
+                return this.rootStore.poiTypeStore.poiTypes.find((pt) => pt.name.toLowerCase() === name.toLowerCase());
+            })
+                .filter((pt) => pt !== undefined && pt !== null);
+            if (selectedPoiTypes.length > 0) {
+                uiState.selectedPoiTypeFilters = selectedPoiTypes;
+                logger.log('URLFilterManager applied POI types:', selectedPoiTypes.map((pt) => pt.name));
+                setTimeout(() => {
+                    this.focusOnFilteredBooths();
+                    this.rootStore.searchStore.setFocused(true);
+                }, 100);
+            }
+            else {
+                logger.warn('URLFilterManager: no POI types found for names:', this.currentFilters.poiTypes);
+                this.currentFilters.poiTypes = [];
+            }
+        }
+        if (this.currentFilters.exhibitors) {
+            this.openExhibitorsList();
+        }
+    }
+    /**
+     * The active filters' contribution to `location.search` — `''` when no
+     * filter is active, else `'?<legacy filter keys>'`, byte-identical to what
+     * `updateURLFromFilters` writes. Also read by the URL autorun (url-dispatch):
+     * when nothing else claims the URL, the filter query IS the selection. Both
+     * writers must emit the same string — emitting different ones made their
+     * MobX ordering decide the final address bar (the poiType-clearing race).
+     */
+    filterSearch() {
+        const { uiState } = this.rootStore;
+        const urlParams = new URLSearchParams();
+        if (uiState.selectedCategoryFilters.length > 0) {
+            const categoryNames = uiState.selectedCategoryFilters.map((cat) => cat.name.toLowerCase());
+            const encodedCategories = encodeStringArray(categoryNames);
+            if (encodedCategories) {
+                urlParams.set(URL_PARAMS.CATEGORIES, encodedCategories);
+            }
+        }
+        if (uiState.selectedPoiTypeFilters.length > 0 && uiState.selectedCategoryFilters.length === 0) {
+            if (uiState.selectedPoiTypeFilters.length === 1) {
+                const poiTypeName = uiState.selectedPoiTypeFilters[0].name.toLowerCase();
+                if (poiTypeName) {
+                    const encodedPoiType = encodeString(poiTypeName);
+                    if (encodedPoiType) {
+                        urlParams.set(URL_PARAMS.POI_TYPE, encodedPoiType);
+                    }
+                }
+            }
+            else {
+                const poiTypeNames = uiState.selectedPoiTypeFilters.map((pt) => pt.name.toLowerCase());
+                const encodedPoiTypes = encodeStringArray(poiTypeNames);
+                if (encodedPoiTypes) {
+                    urlParams.set(URL_PARAMS.POI_TYPES, encodedPoiTypes);
+                }
+            }
+        }
+        if (this.currentFilters.exhibitors &&
+            uiState.selectedCategoryFilters.length === 0 &&
+            uiState.selectedPoiTypeFilters.length === 0) {
+            urlParams.set(URL_PARAMS.EXHIBITORS, 'true');
+        }
+        return urlParams.toString() ? `?${urlParams.toString()}` : '';
+    }
+    updateURLFromFilters() {
+        const { uiState } = this.rootStore;
+        // through the single URL writer — a raw replaceState would desync the
+        // history library's own location and bypass the navigation trail
+        replaceQuery(this.filterSearch());
+        this.currentFilters = {
+            categories: uiState.selectedCategoryFilters.length > 0
+                ? uiState.selectedCategoryFilters.map((cat) => cat.name)
+                : [],
+            poiType: uiState.selectedPoiTypeFilters.length === 1 && uiState.selectedCategoryFilters.length === 0
+                ? uiState.selectedPoiTypeFilters[0].name
+                : null,
+            poiTypes: uiState.selectedPoiTypeFilters.length > 1 && uiState.selectedCategoryFilters.length === 0
+                ? uiState.selectedPoiTypeFilters.map((pt) => pt.name)
+                : [],
+            exhibitors: this.currentFilters.exhibitors,
+        };
+    }
+    setCategories(categoryNames) {
+        this.currentFilters.categories = toLowerCaseArray(categoryNames);
+        this.currentFilters.poiType = null;
+        if (this.isInitialized) {
+            this.updateURLFromFilters();
+        }
+    }
+    setPoiType(poiTypeName) {
+        this.currentFilters.poiType = toLowerCaseString(poiTypeName);
+        this.currentFilters.poiTypes = [];
+        this.currentFilters.categories = [];
+        if (this.isInitialized) {
+            this.updateURLFromFilters();
+        }
+    }
+    setPoiTypes(poiTypeNames) {
+        this.currentFilters.poiTypes = toLowerCaseArray(poiTypeNames);
+        this.currentFilters.poiType = null;
+        this.currentFilters.categories = [];
+        if (this.isInitialized) {
+            this.updateURLFromFilters();
+        }
+    }
+    clearAllFilters() {
+        this.currentFilters = { categories: [], poiType: null, poiTypes: [], exhibitors: false };
+        const { uiState } = this.rootStore;
+        uiState.categoryFilterOpen = false;
+        this.updateURLFromFilters();
+    }
+    getCurrentFilters() {
+        return { ...this.currentFilters };
+    }
+    setupReactions() {
+        planReaction(() => this.rootStore.uiState.selectedCategoryFilters, (categories) => {
+            if (this.isInitialized && categories.length > 0) {
+                const categoryNames = toLowerCaseArray(categories.map((cat) => cat.name));
+                this.setCategories(categoryNames);
+            }
+        });
+        planReaction(() => this.rootStore.uiState.selectedPoiTypeFilters, (poiTypes) => {
+            if (this.isInitialized && poiTypes.length > 0) {
+                if (poiTypes.length === 1) {
+                    const poiTypeName = toLowerCaseString(poiTypes[0].name);
+                    if (poiTypeName) {
+                        this.setPoiType(poiTypeName);
+                    }
+                }
+                else {
+                    const poiTypeNames = toLowerCaseArray(poiTypes.map((pt) => pt.name));
+                    this.setPoiTypes(poiTypeNames);
+                }
+            }
+        });
+    }
+    validateFilters(filters) {
+        if (filters.categories.length > 0 && (filters.poiType || filters.poiTypes.length > 0)) {
+            logger.warn('Categories and POI types cannot be active simultaneously');
+            return false;
+        }
+        if (filters.poiType && filters.poiTypes.length > 0) {
+            logger.warn('Both single POI type and multiple POI types cannot be active simultaneously');
+            return false;
+        }
+        for (const categoryName of filters.categories) {
+            if (!this.getCategoryIdByName(categoryName)) {
+                logger.warn(`Category not found: ${categoryName}`);
+                return false;
+            }
+        }
+        if (filters.poiType && !this.getPoiTypeIdByName(filters.poiType)) {
+            logger.warn(`POI type not found: ${filters.poiType}`);
+            return false;
+        }
+        for (const poiTypeName of filters.poiTypes) {
+            if (!this.getPoiTypeIdByName(poiTypeName)) {
+                logger.warn(`POI type not found: ${poiTypeName}`);
+                return false;
+            }
+        }
+        return true;
+    }
+    getCategoryIdByName(name) {
+        const category = this.rootStore.categoryStore.categories.find((cat) => cat.name.toLowerCase() === name.toLowerCase());
+        return category ? category.id : null;
+    }
+    getPoiTypeIdByName(name) {
+        const poiType = this.rootStore.poiTypeStore.poiTypes.find((pt) => pt.name.toLowerCase() === name.toLowerCase());
+        return poiType ? poiType.id : null;
+    }
+    focusOnFilteredBooths() {
+        if (!this.rootStore.layerStore.layersLoaded) {
+            planReaction(() => this.rootStore.layerStore.layersLoaded, () => {
+                this.focusOnFilteredBooths();
+            }, { fireImmediately: false });
+            return;
+        }
+        const { uiState, exhibitorStore, boothStore } = this.rootStore;
+        let filteredBooths = [];
+        if (uiState.selectedCategoryFilters.length > 0) {
+            const filteredExhibitors = exhibitorStore.exhibitors.filter((exhibitor) => uiState.selectedCategoryFilters.some((category) => exhibitor.categories.some((c) => c.id === category.id)));
+            filteredBooths = boothStore.booths.filter((booth) => filteredExhibitors.some((exhibitor) => exhibitor.id === booth.exhibitors[0]?.id));
+        }
+        if (uiState.selectedPoiTypeFilters.length > 0) {
+            const poiTypeFilteredBooths = boothStore.booths.filter((booth) => uiState.selectedPoiTypeFilters.some((poiType) => booth.poiTypeId === poiType.id));
+            if (filteredBooths.length > 0) {
+                filteredBooths = filteredBooths.filter((booth) => poiTypeFilteredBooths.some((poiBooth) => poiBooth.id === booth.id));
+            }
+            else {
+                filteredBooths = poiTypeFilteredBooths;
+            }
+        }
+        const visibleBooths = filteredBooths.filter((booth) => booth.visible);
+        if (visibleBooths.length > 0) {
+            uiState.moveToBooths = visibleBooths;
+            this.rootStore.moveToList(visibleBooths);
+        }
+        else if (filteredBooths.length > 0) {
+            this.rootStore.showMap();
+            this.rootStore.moveToList(filteredBooths);
+        }
+    }
+    openExhibitorsList() {
+        const { uiState } = this.rootStore;
+        uiState.list = { type: 'exhibitors', text: '', focused: false };
+        setTimeout(() => {
+            this.rootStore.searchStore.setFocused(true);
+        }, 100);
+        logger.log('URLFilterManager opened exhibitors list');
+    }
+}
+__decorate([
+    observable
+], URLFilterManager.prototype, "currentFilters", void 0);
+__decorate([
+    observable
+], URLFilterManager.prototype, "isInitialized", void 0);
+__decorate([
+    action
+], URLFilterManager.prototype, "initialize", null);
+__decorate([
+    action
+], URLFilterManager.prototype, "parseURLFilters", null);
+__decorate([
+    action
+], URLFilterManager.prototype, "applyFiltersToStore", null);
+__decorate([
+    action
+], URLFilterManager.prototype, "updateURLFromFilters", null);
+__decorate([
+    action
+], URLFilterManager.prototype, "setCategories", null);
+__decorate([
+    action
+], URLFilterManager.prototype, "setPoiType", null);
+__decorate([
+    action
+], URLFilterManager.prototype, "setPoiTypes", null);
+__decorate([
+    action
+], URLFilterManager.prototype, "clearAllFilters", null);
+__decorate([
+    action
+], URLFilterManager.prototype, "focusOnFilteredBooths", null);
+__decorate([
+    action
+], URLFilterManager.prototype, "openExhibitorsList", null);

package/dist/esm/services/multi-slug.d.ts

@@ -0,0 +1,20 @@
+/**
+ * The multi-slug share-link rewrite rule, pure for testing (`url-dispatch`'s
+ * `rewriteMultiSlug` binds it to the exhibitor catalog).
+ *
+ * Legacy share links may join several exhibitor slugs with `&` (or with `%26`
+ * when the payload was encoded as one unit). Such a query never selects — the
+ * dispatch falls back to search text — so each part `resolveName` recognizes
+ * is rewritten to the exhibitor's display name, keeping that text readable.
+ *
+ * Only slug-shaped parts count and only they are rewritten: a `key=value`
+ * part (config key, intent shortcut, one-shot, retired key — `=` travels as
+ * `%3D` in the encoded form) is never a slug. A lone slug riding with such
+ * params (`?slug&consent=denied`) is NOT a multi-slug link — left alone, it
+ * flows through the parser's config-stripping to a clean single-slug select.
+ *
+ * Returns the rewritten search (delimiter normalized to `&`), or `null` when
+ * the query is not a multi-slug link.
+ */
+export declare function rewriteMultiSlugQuery(search: string, resolveName: (slugOrId: string) => string | undefined): string | null;
+//# sourceMappingURL=multi-slug.d.ts.map

package/dist/esm/services/multi-slug.js

@@ -0,0 +1,30 @@
+import { safeDecode } from '@expofp/utils';
+/**
+ * The multi-slug share-link rewrite rule, pure for testing (`url-dispatch`'s
+ * `rewriteMultiSlug` binds it to the exhibitor catalog).
+ *
+ * Legacy share links may join several exhibitor slugs with `&` (or with `%26`
+ * when the payload was encoded as one unit). Such a query never selects — the
+ * dispatch falls back to search text — so each part `resolveName` recognizes
+ * is rewritten to the exhibitor's display name, keeping that text readable.
+ *
+ * Only slug-shaped parts count and only they are rewritten: a `key=value`
+ * part (config key, intent shortcut, one-shot, retired key — `=` travels as
+ * `%3D` in the encoded form) is never a slug. A lone slug riding with such
+ * params (`?slug&consent=denied`) is NOT a multi-slug link — left alone, it
+ * flows through the parser's config-stripping to a clean single-slug select.
+ *
+ * Returns the rewritten search (delimiter normalized to `&`), or `null` when
+ * the query is not a multi-slug link.
+ */
+export function rewriteMultiSlugQuery(search, resolveName) {
+    if (!search.includes('&') && !search.includes('%26'))
+        return null;
+    const query = search.startsWith('?') ? search.slice(1) : search;
+    const delimiter = query.includes('&') ? '&' : '%26';
+    const parts = query.split(delimiter);
+    const isSlugPart = (part) => !!part && !safeDecode(part).includes('=');
+    if (parts.filter(isSlugPart).length < 2)
+        return null;
+    return '?' + parts.map((part) => (isSlugPart(part) && resolveName(part)) || part).join('&');
+}

package/dist/esm/services/url-dispatch.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Apply the declarative config nodes onto the runtime state — the presentation
+ * flags and heatmap engagement now, camera and visibility on first layers
+ * load. Runs in EVERY mode, before `initUrlRouting`: `ignoreQuery` isolates
+ * the floor plan from the page URL (`loadConfig` already left the URL slice
+ * out of the effective config), not from its own manifest/options config.
+ */
+export declare function applyDeclarativeConfig(): void;
+export declare function initUrlRouting(offHistory: boolean): void;
+/** The public `FloorPlan.applyParameters` — replay a legacy query at runtime. */
+export declare function applyParameters(queryRaw?: string): void;
+/**
+ * The body of `FloorPlan.showPathway`. Lives here from the days the retired
+ * `?pathway=` deep link shared it; the multi-point-tour header that link
+ * could also raise is `ToursStore.launchTour`'s job now.
+ */
+export declare function applyPathway(options: {
+    pathwayId: string;
+    boothIds: string[];
+    exhibitorIds: string[];
+}): void;
+//# sourceMappingURL=url-dispatch.d.ts.map