@expofp/floorplan 0.0.0-experimental.2d6c681

package/dist/esm/store/journey-plan.js

@@ -0,0 +1,291 @@
+import { observable, reaction } from 'mobx';
+import { setKioskUrlParams } from '../components/Kiosk/kioskUrlParam';
+import data from '../data';
+import { getFpGeo } from '../data/fpGeo.js';
+import { advanceJourneyStage, buildJourneyLink, currentJourneyPlatform, dispatchExternalNavigation, indoorLegOf, initialJourneyStage, readGraphConnectivity, resolveJourneyPlan, } from '../journey';
+import { isOutdoorPoiBooth } from '../utils/outdoor-poi';
+// the leaf, not the adapters barrel: that one re-exports the renderer-backed
+// canvas adapters, and nothing here needs three.js to name a venue
+import { CURRENT_POSITION_POINT_ID, JOURNEY_ENTRANCE_POINT_ID, KIOSK_ANCHOR_POINT_ID, toArbitraryPoint, } from '../wayfinding/adapters/arbitraryPoint';
+import { BoothBase } from './BoothStore';
+import store, { uiState } from './index';
+import { Route } from './RouteStore';
+/** The level layer an endpoint stands on — a booth carries the `Layer` itself,
+ *  an ArbitraryPoint only its name. */
+const layerNameOf = (endpoint) => endpoint instanceof BoothBase ? endpoint.layer?.name : endpoint?.layer;
+/** Where an endpoint sits on the plan: a booth's middle, or the bare point itself. */
+const pointOf = (endpoint) => endpoint instanceof BoothBase ? endpoint.rect?.center : (endpoint ?? undefined);
+/**
+ * The outdoor PoI an endpoint is, or undefined — the whole of the flag gate
+ * ADR-0011 turns on, and the only place in the journey path that reads a flag.
+ *
+ * Three conditions, all of them the producer's own doing: the endpoint is a
+ * booth, it is drawn in an `Outdoor*` layer — its innermost one, the layer the
+ * marker path matched, since `layer` names only the top-level ancestor (an
+ * `_Outdoor` group holding `Outdoor_Booths`) — and the producer turned outdoor
+ * markers on. With the flag off an `Outdoor*` booth draws inline on the
+ * floorplan like any other shape, so it is an ordinary booth here too and
+ * nothing downstream ever hears the word PoI — which is exactly the behavior a
+ * plan that opted into nothing keeps.
+ *
+ * The slug is the identity a PoI travels on, since a PoI is not resolvable from
+ * a layer name the way a venue is. A booth without one cannot be named to the
+ * planner, or carried in a deep link, so it is not a journey place.
+ */
+export function outdoorPoiOf(endpoint) {
+    // where every part of the outdoor-PoI feature agrees on what a PoI is: the
+    // flag and the layer the booth is drawn in, read from one place
+    if (!(endpoint instanceof BoothBase) || !isOutdoorPoiBooth(endpoint) || !endpoint.slug)
+        return undefined;
+    return { id: endpoint.slug, name: endpoint.name };
+}
+/**
+ * The route's FROM endpoint read as a journey origin — the three sources the
+ * glossary names, told apart by what the endpoint is: a picked booth, or the
+ * ArbitraryPoint the app anchors a kiosk and a live position on.
+ *
+ * All three reach the planner as one shape, which is what makes a journey work
+ * identically on a phone, a kiosk and a desktop.
+ */
+export function journeyOrigin(from) {
+    const layerName = layerNameOf(from);
+    // Where the visitor stands travels with the origin: the planner picks the
+    // exit door by how far it is from there — and for a PoI origin it is the
+    // place itself, a PoI being a point on the ground and nothing more.
+    const point = pointOf(from);
+    const outdoorPoi = outdoorPoiOf(from);
+    if (!from || from instanceof BoothBase)
+        return { kind: 'selected-booth', layerName, point, outdoorPoi };
+    return {
+        kind: from.id === KIOSK_ANCHOR_POINT_ID ? 'kiosk-anchor' : 'live-position',
+        layerName,
+        point,
+    };
+}
+/**
+ * The route's TO endpoint read as a journey destination: the layer that names
+ * its venue, where it sits on the plan, and the outdoor PoI it is when it is
+ * one. Symmetrical with {@link journeyOrigin} by design — a journey place is a
+ * journey place at either end (ADR-0011).
+ */
+export function journeyDestination(to) {
+    // The destination's own position travels with it: the planner picks the
+    // arrival door by how far it is from the booth the visitor asked for.
+    return {
+        layerName: layerNameOf(to),
+        name: to?.name,
+        point: pointOf(to),
+        outdoorPoi: outdoorPoiOf(to),
+    };
+}
+const running = observable.box(null);
+/**
+ * The same place, as far as a journey is concerned.
+ *
+ * A live position is one endpoint that keeps moving: as the visitor walks, the
+ * SDK rebuilds the route from their new fix (`syncRouteWithPosition`), which
+ * produces a fresh `Route` for what is still the same journey origin. Reading
+ * those two as different places is what would end a journey the moment its
+ * owner took a step.
+ */
+const sameJourneyEndpoint = (a, b) => a === b ||
+    (!!a && !!b && a.id === CURRENT_POSITION_POINT_ID && b.id === CURRENT_POSITION_POINT_ID);
+/**
+ * Whether a route on the map is still one of the journey's own — the pair the
+ * visitor asked for, or the leg they are being walked through.
+ *
+ * By endpoints rather than by object, because the SDK replaces the `Route`
+ * itself for reasons that have nothing to do with the visitor's intent. Only a
+ * route that goes somewhere else is the visitor asking for something else.
+ */
+function belongsToJourney(active, route) {
+    return [active.request, active.legRoute].some((own) => own && sameJourneyEndpoint(route?.from, own.from) && route?.to === own.to);
+}
+/**
+ * What the journey planner makes of the route the app is showing right now, or
+ * null while there is no endpoint pair to decide about.
+ *
+ * The planner owns every decision; this only gathers what the app knows — the
+ * two endpoints, the graph's answer for them, the plan's georeference and the
+ * producer's config — from the singletons that hold it. Reading observables
+ * makes it usable both inside an observer component and from a MobX reaction,
+ * so the panel and the map draw the same journey without either owning it.
+ *
+ * A journey under way is planned from the pair the visitor asked for rather
+ * than from whichever leg is on the map, and the graph's answer for that pair
+ * is already known: it said unreachable, which is the only reason there is a
+ * journey to be part-way through. Re-planning rather than remembering is what
+ * keeps a running journey answering with the plan the device has now.
+ */
+export function currentJourneyPlan() {
+    const active = running.get();
+    const route = active?.request ?? uiState.selectedRoute;
+    const connectivity = active
+        ? 'unreachable'
+        : readGraphConnectivity({
+            hasOrigin: !!route?.from,
+            hasDestination: !!route?.to,
+            routed: !!route && store.routeStore.routedRoute === route,
+            routeLineCount: store.routeStore.routeLines.length,
+        });
+    if (!connectivity)
+        return null;
+    return resolveJourneyPlan({
+        venues: store.venueStore,
+        gpsConfig: getFpGeo()?.properties?.config,
+        enabled: data.crossVenueJourneys === true,
+        platform: currentJourneyPlatform(),
+        providerOverride: data.mapsProvider,
+    }, journeyOrigin(route?.from), journeyDestination(route?.to), connectivity);
+}
+/** The journey the app is presenting, or null when no journey applies. */
+export function currentJourney() {
+    const plan = currentJourneyPlan();
+    return plan?.outcome === 'journey' ? plan.journey : null;
+}
+/**
+ * The journey the app is showing, as the two identifiers a deep link carries —
+ * or null while there is no destination to name. Only booth endpoints have a
+ * slug: a kiosk anchor and a live position are the DEVICE's, so they never
+ * travel, which is exactly what leaves the receiving phone free to start the
+ * journey from wherever it is.
+ */
+function currentJourneyLink() {
+    // The pair the visitor asked for, not whichever leg is on the map: a door has
+    // no slug, so a QR read off the leg route would blank out mid-journey.
+    const { from, to } = running.get()?.request ?? uiState.selectedRoute ?? {};
+    const toSlug = to instanceof BoothBase ? to.slug : undefined;
+    if (!toSlug)
+        return null;
+    const fromSlug = from instanceof BoothBase ? from.slug : undefined;
+    return fromSlug ? { to: toSlug, from: fromSlug } : { to: toSlug };
+}
+/**
+ * The URL a journey QR encodes: the plan's own address plus the journey's
+ * identifiers, and — as with the route QR beside it — the kiosk anchor, so a
+ * phone that has no fix of its own still starts where the kiosk stands.
+ */
+export function currentJourneyLinkUrl() {
+    const link = currentJourneyLink();
+    if (!link)
+        return null;
+    const url = new URL(buildJourneyLink(uiState.baseQRCodeUrl, link));
+    // short on purpose: a QR beside a journey panel is small, and the anchor's
+    // three fields — all `setKioskUrlParams` writes — are all the receiving
+    // device can use
+    setKioskUrlParams(url.searchParams, uiState.kioskData);
+    return url.toString();
+}
+/**
+ * Offer the journey's external handoff to the host app, and report whether the
+ * host took it — `true` meaning the SDK opens nothing.
+ *
+ * The deep link travels here on every surface, unlike the QR beside the panel:
+ * a native host that discards its WebView during the maps round trip has
+ * nothing else to reopen the journey with.
+ */
+export function offerExternalNavigation(journey) {
+    return dispatchExternalNavigation({
+        journey,
+        deepLink: currentJourneyLinkUrl() ?? undefined,
+        onExternalNavigation: store.fp.onExternalNavigation,
+    });
+}
+/**
+ * Put the leg of a stage on the map, as an ordinary route between two ordinary
+ * endpoints. This is the whole of what a door ever does to the wayfinding
+ * engine: it arrives as an off-graph point on a level, the shape the kiosk
+ * anchor has always arrived in, and the engine snaps and routes it knowing
+ * nothing about entrances (ADR-0010).
+ *
+ * The street leg has no route to show, so it leaves the exit route standing —
+ * the visitor is looking at a maps app, and the plan they come back to should
+ * be the one they left. A door whose level the plan never produced has no
+ * endpoint to offer either, and likewise changes nothing.
+ */
+function showJourneyStage(journey, stage) {
+    const active = running.get();
+    const leg = indoorLegOf(journey, stage);
+    const door = leg?.door;
+    if (!active || !leg || !door?.layerName)
+        return;
+    const endpoint = toArbitraryPoint({ x: door.local.x, y: door.local.y, z: door.layerName }, leg.label, JOURNEY_ENTRANCE_POINT_ID);
+    const legRoute = leg.kind === 'exit'
+        ? new Route(active.request.from, endpoint)
+        : new Route(endpoint, active.request.to);
+    running.set({ ...active, legRoute });
+    // immediate, and without resetting the list: the visitor asked for one thing
+    // and is being walked through it in stages, not sent back to a search box.
+    store.routeStore.selectRoute(legRoute, false, true);
+}
+/**
+ * Start walking a journey the planner has just proposed, on its first stage.
+ *
+ * On a kiosk that first stage matters most: the exit route appears on the
+ * kiosk's own screen, beside the QR, so the walk to the door can begin before
+ * the visitor has taken their phone out.
+ */
+function startJourney(journey) {
+    const request = uiState.selectedRoute;
+    if (!request)
+        return;
+    const stage = initialJourneyStage(journey);
+    running.set({ request, stage, legRoute: null });
+    showJourneyStage(journey, stage);
+}
+/** Which stage of the running journey the visitor is on, or null when none is. */
+export const runningJourneyStage = () => running.get()?.stage ?? null;
+/** Move the running journey on, and show whatever the new stage has to show. */
+export function advanceJourney(event) {
+    const active = running.get();
+    const journey = currentJourney();
+    if (!active || !journey)
+        return;
+    const stage = advanceJourneyStage(journey, active.stage, event);
+    if (stage === active.stage)
+        return;
+    running.set({ ...active, stage });
+    showJourneyStage(journey, stage);
+}
+/**
+ * Keep the journey in step with the visitor: start one when the planner
+ * proposes it, land them on the arrival leg when they come back from the maps
+ * app, and let the journey go when they ask for something else.
+ *
+ * Coming back is read off the page rather than off the handoff, because the
+ * SDK does not own what happens in between — the visitor may return in seconds
+ * from a mis-tapped link or in an hour from another part of the city, and on a
+ * native host the WebView may have been discarded and deep-linked back. All
+ * three arrive here the same way, and the stage machine decides whether any of
+ * it counts as progress.
+ */
+export function bindJourneyProgress() {
+    const onReturn = () => {
+        if (document.visibilityState === 'visible')
+            advanceJourney('return');
+    };
+    document.addEventListener('visibilitychange', onReturn);
+    window.addEventListener('focus', onReturn);
+    const disposers = [
+        // Only ever looked at while no journey runs: a running one re-plans itself
+        // from its own request, and re-reading it here would restart it every time
+        // the plan changed underneath.
+        reaction(() => (running.get() ? null : currentJourney()), (journey) => journey && startJourney(journey), { fireImmediately: true }),
+        // The visitor choosing another route ends the journey — but walking one of
+        // its own legs does not, which is the whole reason the request is kept.
+        reaction(() => uiState.selectedRoute, (route) => {
+            const active = running.get();
+            if (active && !belongsToJourney(active, route))
+                running.set(null);
+        }),
+    ];
+    return () => {
+        document.removeEventListener('visibilitychange', onReturn);
+        window.removeEventListener('focus', onReturn);
+        disposers.forEach((dispose) => dispose());
+        // The box outlives this binding, so a journey left running would be read
+        // back by the next plan loaded into the page — against its venues, its
+        // booths, and a `Route` from a plan that no longer exists.
+        running.set(null);
+    };
+}

package/dist/esm/store/live-store.d.ts

@@ -0,0 +1,19 @@
+import type RootStore from './RootStore.js';
+/**
+ * Points the store barrel's exports at the store graph of the plan being
+ * loaded, or at nothing once it has been destroyed. Called by the load path;
+ * nothing else should touch it.
+ */
+export declare function setLiveStore(next: RootStore | null): void;
+export declare const store: RootStore;
+export declare const uiState: import("./UIState.js").default;
+export declare const overlayStore: import("./OverlayStore.js").default;
+export declare const exhibitorStore: import("./ExhibitorStore.js").default;
+export declare const boothStore: import("./BoothStore.js").default;
+export declare const categoryStore: import("./CategoryStore.js").default;
+export declare const layersStore: import("./LayerStore.js").default;
+export declare const heatmapStore: import("./HeatmapStore.js").default;
+export declare const searchStore: import("./SearchStore.js").default;
+export declare const toursStore: import("./ToursStore.js").default;
+export declare const intercomStore: import("./IntercomStore.js").default;
+//# sourceMappingURL=live-store.d.ts.map

package/dist/esm/store/live-store.js

@@ -0,0 +1,26 @@
+import { createSwappableProxy } from '../utils/swappable-proxy.js';
+// The instance belonging to the live plan, or null while no plan is loaded.
+// Import-time state only ever changes through `setLiveStore`, so the exported
+// proxies below outlive any number of plan swaps.
+let liveStore = null;
+/**
+ * Points the store barrel's exports at the store graph of the plan being
+ * loaded, or at nothing once it has been destroyed. Called by the load path;
+ * nothing else should touch it.
+ */
+export function setLiveStore(next) {
+    liveStore = next;
+}
+// The barrel's public surface. Each name is exactly what `store/index.ts`
+// exports, so the dead-window error quotes the name the importer wrote.
+export const store = createSwappableProxy('store', () => liveStore);
+export const uiState = createSwappableProxy('uiState', () => liveStore?.uiState);
+export const overlayStore = createSwappableProxy('overlayStore', () => liveStore?.overlayStore);
+export const exhibitorStore = createSwappableProxy('exhibitorStore', () => liveStore?.exhibitorStore);
+export const boothStore = createSwappableProxy('boothStore', () => liveStore?.boothStore);
+export const categoryStore = createSwappableProxy('categoryStore', () => liveStore?.categoryStore);
+export const layersStore = createSwappableProxy('layersStore', () => liveStore?.layerStore);
+export const heatmapStore = createSwappableProxy('heatmapStore', () => liveStore?.heatmapStore);
+export const searchStore = createSwappableProxy('searchStore', () => liveStore?.searchStore);
+export const toursStore = createSwappableProxy('toursStore', () => liveStore?.toursStore);
+export const intercomStore = createSwappableProxy('intercomStore', () => liveStore?.intercomStore);

package/dist/esm/store/outdoor-poi-filter.d.ts

@@ -0,0 +1,21 @@
+import { type PoiMarker } from './PoiMarkerStore';
+export interface OutdoorPoiFilterState {
+    active: boolean;
+    /** Stable key over the matching booth ids — the change signal for reactions. */
+    key: string;
+    matchingMarkers: PoiMarker[];
+}
+export declare const EMPTY_OUTDOOR_POI_FILTER_STATE: OutdoorPoiFilterState;
+/** The subset of a booth the outdoor PoI filter looks at. */
+export interface PoiFilterBooth {
+    id: number;
+    poiTypeId?: number | null;
+}
+/**
+ * Pure core of `PoiMarkerStore.outdoorFilter`. The filter targets the
+ * *rendered* outdoor markers: booths matching the selected poiType but without
+ * a marker (indoor booths sharing the type, or markers still rasterizing) are
+ * skipped, and the filter is inactive only when no marker matched at all.
+ */
+export declare function computeOutdoorPoiFilterState(selectedPoiTypeIds: readonly number[], hasCategoryFilters: boolean, booths: readonly PoiFilterBooth[], markers: readonly PoiMarker[]): OutdoorPoiFilterState;
+//# sourceMappingURL=outdoor-poi-filter.d.ts.map

package/dist/esm/store/outdoor-poi-filter.js

@@ -0,0 +1,33 @@
+export const EMPTY_OUTDOOR_POI_FILTER_STATE = {
+    active: false,
+    key: '',
+    matchingMarkers: [],
+};
+/**
+ * Pure core of `PoiMarkerStore.outdoorFilter`. The filter targets the
+ * *rendered* outdoor markers: booths matching the selected poiType but without
+ * a marker (indoor booths sharing the type, or markers still rasterizing) are
+ * skipped, and the filter is inactive only when no marker matched at all.
+ */
+export function computeOutdoorPoiFilterState(selectedPoiTypeIds, hasCategoryFilters, booths, markers) {
+    if (!selectedPoiTypeIds.length || hasCategoryFilters) {
+        return EMPTY_OUTDOOR_POI_FILTER_STATE;
+    }
+    const selectedPoiTypeIdSet = new Set(selectedPoiTypeIds);
+    const markerByBoothId = new Map(markers.map((marker) => [marker.boothId, marker]));
+    const matchingMarkers = [];
+    for (const booth of booths) {
+        if (booth.poiTypeId == null || !selectedPoiTypeIdSet.has(booth.poiTypeId))
+            continue;
+        const marker = markerByBoothId.get(booth.id);
+        if (marker)
+            matchingMarkers.push(marker);
+    }
+    if (!matchingMarkers.length) {
+        return EMPTY_OUTDOOR_POI_FILTER_STATE;
+    }
+    const key = [...new Set(matchingMarkers.map((marker) => marker.boothId))]
+        .sort((a, b) => a - b)
+        .join(',');
+    return { active: true, key, matchingMarkers };
+}

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

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

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

@@ -0,0 +1,59 @@
+import { __decorate } from "tslib";
+// @ts-nocheck
+import { computed } from 'mobx';
+import { BaseShortcutProvider } from '../ShortcutProvider';
+export class SearchShortcutProvider extends BaseShortcutProvider {
+    constructor(rootStore) {
+        super();
+        this.rootStore = rootStore;
+        this.id = 'search';
+    }
+    createShortcuts() {
+        const { searchButtonsStore } = this.rootStore;
+        const shortcuts = [];
+        const activeParentButton = searchButtonsStore.getActiveParent();
+        if (activeParentButton && activeParentButton.children) {
+            const visibleChildren = activeParentButton.children.filter((child) => child.visible);
+            if (activeParentButton.type === 'poi_types' && visibleChildren.length === 1) {
+                return shortcuts;
+            }
+            visibleChildren.forEach((child) => {
+                if (child.type === 'poi_types' || child.type === 'categories') {
+                    const childId = child.id?.toString() || child.name;
+                    const isActive = searchButtonsStore.isChildActive(childId);
+                    shortcuts.push({
+                        id: childId,
+                        label: child.name,
+                        enabled: true,
+                        active: isActive,
+                        tooltip: isActive
+                            ? `Remove ${child.name} from filter (show all ${activeParentButton.name})`
+                            : `Filter only by ${child.name}`,
+                        variant: 'default',
+                        action: 'toggle',
+                        showResetButton: false,
+                    });
+                }
+            });
+        }
+        return shortcuts;
+    }
+    get shortcuts() {
+        return this.createShortcuts();
+    }
+    shouldShowShortcuts() {
+        const { searchButtonsStore } = this.rootStore;
+        return searchButtonsStore.hasActiveParentWithChildren;
+    }
+    handleShortcutClick(shortcutId) {
+        const { searchButtonsStore } = this.rootStore;
+        searchButtonsStore.toggleChildFilter(shortcutId);
+    }
+    handleShortcutReset() {
+        const { searchButtonsStore } = this.rootStore;
+        searchButtonsStore.clearAllChildFilters();
+    }
+}
+__decorate([
+    computed
+], SearchShortcutProvider.prototype, "shortcuts", null);

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

@@ -0,0 +1,17 @@
+import type RootStore from '../RootStore';
+import { BaseShortcutProvider, type ShortcutConfig } from '../ShortcutProvider';
+export declare class SessionsShortcutProvider extends BaseShortcutProvider {
+    private rootStore;
+    readonly id = "sessions";
+    constructor(rootStore: RootStore);
+    private get computedShortcuts();
+    createShortcuts(): ShortcutConfig[];
+    handleShortcutClick(shortcutId: string): void;
+    handleShortcutReset(shortcutId: string): void;
+    shouldShowShortcuts(): boolean;
+    private toggleBookmarksFilter;
+    private toggleLiveFilter;
+    private toggleDateFilter;
+    private toggleSortOrder;
+}
+//# sourceMappingURL=SessionsShortcutProvider.d.ts.map