@expofp/floorplan 0.0.0-experimental.2d6c681

package/dist/esm/store/init/init-heatmap.js

@@ -0,0 +1,37 @@
+import { createCurrentCanvas, cssSizeOf } from '../../components/Map/drawing/config/canvases';
+import { HeatmapYah } from '../HeatmapStore';
+export function initHeatmap(store) {
+    if (window['__heatmapData']) {
+        store.heatmapStore.heatmapData = window['__heatmapData'];
+    }
+    else if (window['__heatmapDataYah']) {
+        store.heatmapStore.heatmapData.yah = window['__heatmapDataYah'].yah.map((item) => new HeatmapYah(item.id, item.name, item.viewCount, item.x, item.y, item.z));
+        const icons = store.heatmapStore.heatmapData.yah.map((yah) => {
+            const color = store.heatmapStore.getColorByClicks(yah.viewCount);
+            const pixelRatio = store.uiState.devicePixelRatio;
+            const canvas = createCurrentCanvas(pixelRatio, color, undefined, 95, 120, yah.viewCount.toString());
+            const base64 = canvas.toDataURL();
+            return {
+                name: yah.id.toString(),
+                scale: 1,
+                // CSS pixels, which is what an icon's size is stated in; the canvas is rasterized at the
+                // device ratio and its backing width says how crisp it is, not how big.
+                ...cssSizeOf(canvas),
+                content: base64,
+            };
+        });
+        const markers = store.heatmapStore.heatmapData.yah.map((yah) => {
+            return {
+                id: yah.id.toString(),
+                x: yah.x,
+                y: yah.y,
+                z: yah.z,
+                position: 'lefttop',
+                icon: yah.id.toString(),
+                selectedIcon: yah.id.toString(),
+            };
+        });
+        store.routeStore.setMarkers({ markers, icons });
+        store.selectSearch(' '); // TODO: refactor to avoid this hack to show heatmap list on load
+    }
+}

package/dist/esm/store/init/init-layers.d.ts

@@ -0,0 +1,8 @@
+import { Layer } from '../LayerStore';
+import type RootStore from '../RootStore';
+export declare function getChildLayers(layer: Layer, currentPriority: number, priorityStep: number): {
+    layers: Layer[];
+    priority: number;
+};
+export default function initLayers(store: RootStore): void;
+//# sourceMappingURL=init-layers.d.ts.map

package/dist/esm/store/init/init-layers.js

@@ -0,0 +1,151 @@
+/* eslint-disable prefer-const */
+// @ts-nocheck
+import { Box, isBox } from '@expofp/geometry';
+import { select } from 'd3';
+import { getFpSvgJs } from '../../data/fp-payloads';
+import { getFloors, getLayerSvg } from '../../data/svg.js';
+import { isPathwayLayer } from '../../utils/is-pathway-layer';
+import { Layer, LayerMode, LayersMode } from '../LayerStore';
+const STEP_PRIORITY = 1000;
+/**
+ * Normalizes a layer rect coming from the `__fpLayers` platform global to a
+ * geometry {@link Box}. The platform's `fp.svg.js` emits the rect in the legacy
+ * `core/Rect` shape (`x1/y1/x2/y2`), so convert when it is not already a Box.
+ * Returns `null`/`undefined` unchanged.
+ */
+function toLayerBox(rect) {
+    if (rect == null)
+        return rect;
+    if (isBox(rect))
+        return rect;
+    return Box.fromMinMax({ x: rect.x1, y: rect.y1 }, { x: rect.x2, y: rect.y2 });
+}
+export function getChildLayers(layer, currentPriority, priorityStep) {
+    const childLayers = [];
+    let priority = currentPriority;
+    const children = select(getLayerSvg(layer))
+        .selectAll(`svg [data-layer="${layer.name}"] > [data-layer]`)
+        .nodes()
+        .filter((n) => n.childNodes.length);
+    children.forEach((childLayer) => {
+        const layerID = childLayer.getAttribute('data-layer');
+        let child = new Layer();
+        child.name = childLayer.getAttribute('data-layer');
+        child.visible = layer.visible;
+        child.description = childLayer.getAttribute('data-layer-description') || layerID;
+        child.frozen = childLayer.getAttribute('data-layer-isfrozen') === 'true' ? true : false;
+        child.rect = layer.rect;
+        child.viewbox = layer.viewbox;
+        child.mode = LayerMode.Unset;
+        child.rootParent = layer.rootParent ? layer.rootParent : layer;
+        const grandChildResult = getChildLayers(child, priority, priorityStep);
+        priority = grandChildResult.priority + priorityStep;
+        child.basePriority = priority;
+        if (grandChildResult.layers.length) {
+            child.childLayers = grandChildResult.layers;
+            childLayers.push(...grandChildResult.layers);
+        }
+        childLayers.push(child);
+    });
+    return { layers: childLayers, priority };
+}
+export default function initLayers(store) {
+    const { layerStore } = store;
+    const fpLayers = getFpSvgJs().__fpLayers;
+    layerStore.mode = getFpSvgJs().__fpLayersMode || LayersMode.Default;
+    // `?layer=<short label>` — the floor shown on load, matched against each layer's floor-picker
+    // short name, case-insensitive (documented in pages/reference/query-parameters.md#layer).
+    // Direct read on purpose: consumed only here, at SVG-layer init.
+    const initLayer = new URLSearchParams(window.location.search).get('layer');
+    const isvisible = (layer, shortName) => {
+        if (initLayer)
+            return shortName.toLowerCase() === initLayer.toLowerCase();
+        if (layerStore.mode !== LayersMode.Default)
+            return layer.mode == LayerMode.TurnedOn;
+        return layer.visible;
+    };
+    let layers = [];
+    let priority = 0;
+    if (fpLayers) {
+        fpLayers.forEach((layer) => {
+            priority += STEP_PRIORITY;
+            let l = new Layer();
+            l.name = layer.name;
+            l.description = layer.description;
+            l.frozen = layer.frozen;
+            l.visible = isvisible(layer, l.shortName);
+            l.rect = toLayerBox(layer.rect);
+            l.viewbox = toLayerBox(layer.viewbox);
+            l.mode = layer.mode || LayerMode.Unset;
+            l.basePriority = priority;
+            l.floorIndex = layer.floorIndex;
+            layers.push(l);
+        });
+    }
+    else {
+        select(getLayerSvg())
+            .selectAll('svg > [data-layer]')
+            .nodes()
+            .filter((n) => n.childNodes.length)
+            .forEach((layer) => {
+            const layerID = layer.getAttribute('data-layer');
+            if (!layerID.startsWith('WF')) {
+                priority += STEP_PRIORITY;
+                let l = new Layer();
+                l.name = layerID;
+                l.visible = true;
+                l.description = layer.getAttribute('data-layer-description') || layerID;
+                l.frozen = layer.getAttribute('data-layer-isfrozen') === 'true' ? true : false;
+                l.rect = getFloors().filter((f) => f.name === l.name || f.name === l.description)[0]
+                    ?.rect;
+                l.mode = LayerMode.Unset;
+                l.basePriority = priority;
+                layers.push(l);
+            }
+        });
+    }
+    // Backward compatibilitty. Remove for future
+    // KNOWN LIMITATION: this block overwrites `visible` from each layer's data
+    // mode, so on non-Default plans whose layers carry TurnedOn/TurnedOff (the
+    // typical multi-floor drawing) it silently discards the `?layer=` choice
+    // applied above — the param only works where layers have no explicit mode.
+    // `?camera[floor]=` switches floors reliably (activateFloor, after boot).
+    if (layerStore.mode !== LayersMode.Default) {
+        layers.forEach((l) => {
+            if (l.mode === LayerMode.AlwaysHidden) {
+                l.frozen = true;
+                l.visible = false;
+            }
+            else if (l.mode === LayerMode.AlwaysVisible) {
+                l.frozen = l.visible = true;
+            }
+            else if (l.mode === LayerMode.TurnedOff) {
+                l.frozen = false;
+                l.visible = false;
+            }
+            else if (l.mode === LayerMode.TurnedOn) {
+                l.frozen = false;
+                l.visible = true;
+            }
+        });
+    }
+    try {
+        layers.forEach((l) => {
+            if (isPathwayLayer(l.name)) {
+                l.frozen = false;
+                l.visible = false;
+                l.pathway = true;
+            }
+        });
+    }
+    catch (err) {
+        console.warn(err);
+    }
+    layers = layers.filter((l) => l.pathway || !l.frozen || (l.frozen && l.visible));
+    layerStore.defaultLayer = layers.find((l) => l.name === getFpSvgJs().__fpDefaultLayer);
+    layerStore.layers = [...layerStore.layers, ...layers];
+    // Venue-model plans (data.venues): build the venue entities and apply the
+    // venue-scoped visibility baseline and quarantine invalid ownership before
+    // floor discovery or either renderer can consume the layer list.
+    store.venueStore.init();
+}

package/dist/esm/store/init/init-poiTypes.d.ts

@@ -0,0 +1,3 @@
+import type RootStore from '../RootStore';
+export declare function initPoiTypes(store: RootStore): void;
+//# sourceMappingURL=init-poiTypes.d.ts.map

package/dist/esm/store/init/init-poiTypes.js

@@ -0,0 +1,6 @@
+import data from '../../data';
+export function initPoiTypes(store) {
+    (data.poiTypes ?? []).forEach((poiType) => {
+        store.poiTypeStore.poiTypes.push(poiType);
+    });
+}

package/dist/esm/store/init/init-speakers.d.ts

@@ -0,0 +1,3 @@
+import RootStore from '../RootStore';
+export default function initSpeakers(store: RootStore): void;
+//# sourceMappingURL=init-speakers.d.ts.map

package/dist/esm/store/init/init-speakers.js

@@ -0,0 +1,20 @@
+/* eslint-disable @typescript-eslint/consistent-type-imports */
+// @ts-nocheck
+import { getStorage, saveStorage } from '../../utils/entity-storage';
+import { planAutorun } from '../../utils/plan-reactions.js';
+export default function initSpeakers(store) {
+    initBookmarked(store.speakerStore);
+}
+function initBookmarked(speakerStore) {
+    const bookmarks = getStorage('bookmarked');
+    speakerStore.replaceBookmarked(bookmarks.speakers);
+    planAutorun(() => {
+        const currentBookmarks = getStorage('bookmarked');
+        saveStorage('bookmarked', {
+            exhibitors: currentBookmarks.exhibitors,
+            events: currentBookmarks.events,
+            speakers: speakerStore.bookmarked?.map((x) => x.id),
+            booths: currentBookmarks.booths,
+        });
+    });
+}

package/dist/esm/store/init/init-ui.d.ts

@@ -0,0 +1,13 @@
+import type RootStore from '../RootStore';
+/**
+ * Point the store at the container this FloorPlan was handed, and measure it.
+ *
+ * Exported apart from `initUi` because `floorplan.ready` re-runs it once the
+ * render target exists. Idempotent: it re-points the single ResizeObserver
+ * instead of stacking another one up, and `destroyUiHandlers()` disconnects
+ * that one with the plan.
+ */
+export declare function bindRootElement(store: RootStore): void;
+export default function initUi(store: RootStore): void;
+export declare function destroyUiHandlers(): void;
+//# sourceMappingURL=init-ui.d.ts.map

package/dist/esm/store/init/init-ui.js

@@ -0,0 +1,155 @@
+import { Point } from '@expofp/geometry';
+import { comparer, runInAction } from 'mobx';
+import { ResizeObserver } from 'resize-observer';
+import { applyKioskMode } from '../../components/Kiosk/kiosk-mode';
+import { KIOSK_ENABLE_KEY, VISIBILITY_STORAGE_KEY } from '../../constants';
+import data from '../../data';
+import { registerPlanDisposer } from '../../plan-lifecycle.js';
+import logger from '../../tools/logger';
+import { isWebGlSupported } from '../../utils';
+import { detectLimitedModeViaImage } from '../../utils/detectLimitedModeViaImage';
+import { isLocalStorageAvailable } from '../../utils/localStorage';
+import { planAutorun, planReaction } from '../../utils/plan-reactions.js';
+import getPreviewExhibitor from '../../utils/preview-exhibitor.js';
+let resizeObserver = null;
+/**
+ * Point the store at the container this FloorPlan was handed, and measure it.
+ *
+ * Exported apart from `initUi` because `floorplan.ready` re-runs it once the
+ * render target exists. Idempotent: it re-points the single ResizeObserver
+ * instead of stacking another one up, and `destroyUiHandlers()` disconnects
+ * that one with the plan.
+ */
+export function bindRootElement(store) {
+    const rootElement = window.__efpElement;
+    if (!rootElement)
+        return;
+    const { uiState } = store;
+    uiState.rootElement = rootElement;
+    const updateScreenSize = (width, height) => runInAction('uiState.screenSize', () => {
+        uiState.screenSize = new Point(width, height);
+    });
+    updateScreenSize(rootElement.clientWidth, rootElement.clientHeight);
+    resizeObserver?.disconnect();
+    resizeObserver = new ResizeObserver((entries) => {
+        entries.forEach((entry) => {
+            updateScreenSize(entry.contentRect.width, entry.contentRect.height);
+        });
+    });
+    resizeObserver.observe(rootElement);
+}
+export default function initUi(store) {
+    const { uiState, exhibitorStore } = store;
+    bindRootElement(store);
+    registerPlanDisposer(destroyUiHandlers);
+    const previewExhibitor = getPreviewExhibitor();
+    if (previewExhibitor) {
+        const exhibitor = exhibitorStore.exhibitorById.get(previewExhibitor.id);
+        if (exhibitor)
+            uiState.previewExhibitor = exhibitor;
+    }
+    // monitor devicePixelRatio changes
+    const mm = typeof matchMedia !== 'undefined'
+        ? matchMedia(`(resolution: ${window.devicePixelRatio}dppx)`)
+        : null;
+    if (mm && mm.addEventListener) {
+        const onResolutionChange = () => {
+            uiState.devicePixelRatio = window.devicePixelRatio;
+        };
+        mm.addEventListener('change', onResolutionChange);
+        registerPlanDisposer(() => mm.removeEventListener('change', onResolutionChange));
+    }
+    const initialOverlaySize = previewExhibitor || !isWebGlSupported ? 'full' : 'medium';
+    if (data.isRebooking && uiState.list.type === 'search' && !uiState.list.text) {
+        store.selectExhibitors();
+    }
+    uiState.desiredOverlaySize = initialOverlaySize;
+    // expand on search focus or menu focus
+    planAutorun(() => {
+        if ((uiState.searchFocused || uiState.menu) && uiState.overlayPosition !== 'left') {
+            uiState.desiredOverlaySize = 'full';
+        }
+    });
+    // remove menu when not full
+    planAutorun(() => {
+        if (uiState.overlaySize !== 'full' && uiState.menu) {
+            uiState.menu = false;
+        }
+    });
+    if (!uiState.wsShown)
+        uiState.wsStarted = true;
+    uiState.kiosk = isLocalStorageAvailable && localStorage.getItem(KIOSK_ENABLE_KEY) === '1';
+    window.__resett = resetTimer;
+    function logout() {
+        store.reset();
+    }
+    let time;
+    registerPlanDisposer(() => clearTimeout(time));
+    function resetTimer() {
+        // Not while the setkiosk panel is open: the idle reset belongs to a kiosk
+        // serving visitors, and an operator placing one is not a visitor gone away.
+        if (!uiState.kiosk || uiState.setKioskModeEnabled) {
+            return;
+        }
+        logger.log('zzz2', 'reset timer');
+        clearTimeout(time);
+        time = setTimeout(logout, 30000);
+        uiState.inIdle = false;
+    }
+    // typed escape hatch for devices without an address bar: `kiosk=1` /
+    // `kiosk=0` in the search box, the canonical words of the `?kiosk=` param —
+    // replaces the retired kkiosk/nokkiosk commands, same helper as the URL arm
+    planAutorun(() => {
+        const list = uiState.list;
+        if (list.type === 'search') {
+            if (list.text === 'kiosk=1') {
+                applyKioskMode(uiState, true);
+            }
+            else if (list.text === 'kiosk=0') {
+                applyKioskMode(uiState, false);
+            }
+        }
+    });
+    // The mode itself is stored by whoever chose it — `applyKioskMode` for the URL
+    // and typed-command channels, the setkiosk panel's own Save and Delete for the
+    // mode it previews — which leaves this reaction the idle timer alone.
+    planReaction(() => [uiState.kiosk, uiState.setKioskModeEnabled], ([kiosk, setKioskOpen]) => {
+        if (kiosk && !setKioskOpen) {
+            resetTimer();
+        }
+        else {
+            // an idle reset still waiting out its timer must not fire once kiosk
+            // mode is off (one already running finishes — RootStore.reset defers)
+            clearTimeout(time);
+        }
+    }, { equals: comparer.structural });
+    if (isLocalStorageAvailable) {
+        uiState.setVisibility(JSON.parse(localStorage.getItem(VISIBILITY_STORAGE_KEY) ?? 'null') || {});
+    }
+    handleUnsupportedMode(store);
+}
+export function destroyUiHandlers() {
+    if (resizeObserver) {
+        resizeObserver.disconnect();
+        resizeObserver = null;
+    }
+}
+async function handleUnsupportedMode(store) {
+    try {
+        const isLimitedMode = await detectLimitedModeViaImage();
+        if (!isLimitedMode) {
+            return;
+        }
+        store.uiState.setGlobalErrorMessage({
+            title: 'Unsupported Environment Detected',
+            body: `
+                This application requires a proper server environment to function correctly.
+                For full functionality, please ensure the application is served through an HTTP/HTTPS server.
+                Some features may not work as expected in the current setup.
+            `.trim(),
+        });
+    }
+    catch (err) {
+        console.error(err);
+    }
+}

package/dist/esm/store/journey-plan.d.ts

@@ -0,0 +1,89 @@
+import { type Journey, type JourneyDestinationEndpoint, type JourneyOriginEndpoint, type JourneyOutdoorPoi, type JourneyPlan, type JourneyStage, type JourneyStageEvent } from '../journey';
+import { type ArbitraryPoint } from '../wayfinding/adapters/arbitraryPoint';
+import { type Booth } from './BoothStore';
+/**
+ * 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 declare function outdoorPoiOf(endpoint: Booth | ArbitraryPoint | null | undefined): JourneyOutdoorPoi | undefined;
+/**
+ * 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 declare function journeyOrigin(from: Booth | ArbitraryPoint | null | undefined): JourneyOriginEndpoint;
+/**
+ * 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 declare function journeyDestination(to: Booth | ArbitraryPoint | null | undefined): JourneyDestinationEndpoint;
+/**
+ * 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 declare function currentJourneyPlan(): JourneyPlan | null;
+/** The journey the app is presenting, or null when no journey applies. */
+export declare function currentJourney(): Journey | null;
+/**
+ * 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 declare function currentJourneyLinkUrl(): string | null;
+/**
+ * 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 declare function offerExternalNavigation(journey: Journey): boolean;
+/** Which stage of the running journey the visitor is on, or null when none is. */
+export declare const runningJourneyStage: () => JourneyStage | null;
+/** Move the running journey on, and show whatever the new stage has to show. */
+export declare function advanceJourney(event: JourneyStageEvent): void;
+/**
+ * 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 declare function bindJourneyProgress(): () => void;
+//# sourceMappingURL=journey-plan.d.ts.map