@expofp/floorplan 0.0.0-experimental.cf063fc

package/dist/esm/store/HeatmapStore.d.ts

@@ -0,0 +1,51 @@
+import Color from 'color';
+import { type GaEventActions } from '../tools/gtag';
+import { BoothBase } from './BoothStore';
+import { Exhibitor } from './ExhibitorStore';
+import { type ListItem } from './types';
+export default class HeatmapStore {
+    heatmapData: HeatmapData;
+    /**
+     * A booth view parked for the next `selectedExhibitor` reaction: a click on
+     * a booth with a single exhibitor opens that exhibitor's card, but counts as
+     * a view of the BOOTH. `exhibitor` is the selection it stands in for — the
+     * reaction honours the entry for that selection only, so one left behind by
+     * a click that changed nothing cannot mislabel a later, unrelated view.
+     */
+    forceTrack: {
+        action: GaEventActions;
+        label: string;
+        exhibitor: Exhibitor;
+    } | null;
+    get minAndMaxClicks(): {
+        min: number;
+        max: number;
+    };
+    getClicksByType(item: ListItem): number;
+    getClicksByItem(item: ListItem | BoothBase): number;
+    getTotalClicksByBooth(b: BoothBase): number;
+    getColorByClicks(clicks: number): string;
+    getHeatmapColorForBooth(booth: BoothBase): Color<string>;
+}
+export interface HeatmapData {
+    booths?: HeatmapItem[];
+    exhibitors?: HeatmapItem[];
+    yah?: HeatmapYah[];
+}
+export declare class HeatmapYah {
+    readonly id: number | string;
+    readonly name: string;
+    readonly viewCount: number;
+    readonly x: number;
+    readonly y: number;
+    readonly z?: number | string | undefined;
+    readonly entity: {
+        readonly type: 'heatmap-yah';
+    };
+    constructor(id: number | string, name: string, viewCount: number, x: number, y: number, z?: number | string | undefined);
+}
+export interface HeatmapItem {
+    id: number | string;
+    viewCount: number;
+}
+//# sourceMappingURL=HeatmapStore.d.ts.map

package/dist/esm/store/HeatmapStore.js

@@ -0,0 +1,100 @@
+import { __decorate } from "tslib";
+/* eslint-disable import/newline-after-import */
+import Color from 'color';
+import { computed } from 'mobx';
+import settings from '../tools/settings';
+import { getColorFromGradient } from '../utils/color-gradient';
+import { BoothBase } from './BoothStore';
+import { Category } from './CategoryStore';
+import { EventItem } from './EventStore';
+import { Exhibitor } from './ExhibitorStore';
+export default class HeatmapStore {
+    constructor() {
+        this.heatmapData = {};
+        /**
+         * A booth view parked for the next `selectedExhibitor` reaction: a click on
+         * a booth with a single exhibitor opens that exhibitor's card, but counts as
+         * a view of the BOOTH. `exhibitor` is the selection it stands in for — the
+         * reaction honours the entry for that selection only, so one left behind by
+         * a click that changed nothing cannot mislabel a later, unrelated view.
+         */
+        // don't observe this
+        this.forceTrack = null;
+    }
+    get minAndMaxClicks() {
+        const { booths = [], exhibitors = [], yah = [] } = this.heatmapData;
+        const allItems = [...booths, ...exhibitors, ...yah];
+        if (allItems.length === 0) {
+            return { min: 0, max: 0 };
+        }
+        const getMinMax = (data) => {
+            return data.reduce((acc, item) => {
+                if (item.viewCount > acc.max)
+                    acc.max = item.viewCount;
+                if (item.viewCount < acc.min)
+                    acc.min = item.viewCount;
+                return acc;
+            }, { min: data[0].viewCount, max: data[0].viewCount });
+        };
+        const { min, max } = getMinMax(allItems);
+        return { min, max };
+    }
+    getClicksByType(item) {
+        if (item instanceof Category) {
+            // -1 is returned for Categories to ensure they appear last in sorted methods
+            return -1;
+        }
+        else if (item instanceof Exhibitor) {
+            return this.getClicksByItem(item);
+        }
+        else if (item instanceof HeatmapYah) {
+            return this.getClicksByItem(item);
+        }
+        else if (item instanceof EventItem) {
+            return 0;
+        }
+        return this.getClicksByItem(item);
+    }
+    getClicksByItem(item) {
+        if (item instanceof Exhibitor) {
+            return this.heatmapData?.exhibitors?.find((a) => a.id === item.id)?.viewCount || 0;
+        }
+        if (item instanceof BoothBase) {
+            return this.heatmapData?.booths?.find((a) => a.id === item.id)?.viewCount || 0;
+        }
+        if (item instanceof HeatmapYah) {
+            return this.heatmapData?.yah?.find((a) => a.id === item.id)?.viewCount || 0;
+        }
+        return 0;
+    }
+    getTotalClicksByBooth(b) {
+        let totalClicks = this.getClicksByItem(b);
+        for (const exhibitor of b.exhibitors) {
+            const clicks = this.getClicksByItem(exhibitor);
+            totalClicks += clicks;
+        }
+        return totalClicks;
+    }
+    getColorByClicks(clicks) {
+        const { min, max } = this.minAndMaxClicks;
+        return getColorFromGradient(clicks, min, max, settings.heatmapColors);
+    }
+    getHeatmapColorForBooth(booth) {
+        const totalClicks = this.getTotalClicksByBooth(booth);
+        return Color(this.getColorByClicks(totalClicks));
+    }
+}
+__decorate([
+    computed({ keepAlive: true })
+], HeatmapStore.prototype, "minAndMaxClicks", null);
+export class HeatmapYah {
+    constructor(id, name, viewCount, x, y, z) {
+        this.id = id;
+        this.name = name;
+        this.viewCount = viewCount;
+        this.x = x;
+        this.y = y;
+        this.z = z;
+        this.entity = { type: 'heatmap-yah' };
+    }
+}

package/dist/esm/store/IntercomStore.d.ts

@@ -0,0 +1,7 @@
+export default class IntercomStore {
+    enabled: boolean;
+    unreadCount: number;
+    setEnabled(value: boolean): void;
+    setUnreadCount(count: number): void;
+}
+//# sourceMappingURL=IntercomStore.d.ts.map

package/dist/esm/store/IntercomStore.js

@@ -0,0 +1,26 @@
+import { __decorate } from "tslib";
+import { action, observable } from 'mobx';
+export default class IntercomStore {
+    constructor() {
+        this.enabled = false;
+        this.unreadCount = 0;
+    }
+    setEnabled(value) {
+        this.enabled = value;
+    }
+    setUnreadCount(count) {
+        this.unreadCount = count;
+    }
+}
+__decorate([
+    observable
+], IntercomStore.prototype, "enabled", void 0);
+__decorate([
+    observable
+], IntercomStore.prototype, "unreadCount", void 0);
+__decorate([
+    action
+], IntercomStore.prototype, "setEnabled", null);
+__decorate([
+    action
+], IntercomStore.prototype, "setUnreadCount", null);

package/dist/esm/store/LayerStore.d.ts

@@ -0,0 +1,70 @@
+import { Box } from '@expofp/geometry';
+import { type LayerDef } from '@expofp/renderer';
+import { type Floor } from '../types';
+import type RootStore from './RootStore';
+export declare enum LayersMode {
+    Default = 0,// one floor plans
+    Separated = 1,// outdated
+    Radio = 2,// multi floor plans
+    CheckBox = 3
+}
+export declare enum LayerMode {
+    Unset = 0,
+    AlwaysVisible = 1,
+    AlwaysHidden = 2,
+    TurnedOn = 3,
+    TurnedOff = 4
+}
+export declare class Layer {
+    basePriority: number;
+    name: string;
+    description: string;
+    frozen: boolean;
+    rect: Box | null;
+    viewbox: Box | null;
+    configured: boolean;
+    childLayers: Layer[];
+    rootParent: Layer | null;
+    mode: LayerMode;
+    children: LayerDef[];
+    pathway?: boolean;
+    floorIndex?: number;
+    loaded: boolean;
+    visible: boolean;
+    get shortName(): string;
+}
+export default class LayerStore {
+    layers: Layer[];
+    defaultLayer?: Layer;
+    mode: LayersMode;
+    layersLoaded: boolean;
+    quarantinedLayerNames: string[];
+    rootStore: RootStore;
+    private selectFloorTimeout;
+    private readonly floorActivatedNotifier;
+    constructor(rootStore: RootStore);
+    get visible(): Layer[];
+    get loaded(): Layer[];
+    get rectangle(): Box | null;
+    /** Union of all layers' rects to use as a bounds for camera */
+    get bounds(): Box | undefined;
+    get viewboxRectangle(): Box | null;
+    get pathwayLayers(): Layer[];
+    get venueLayers(): Layer[];
+    get floors(): (Floor & {
+        layer: Layer;
+    })[];
+    selectFloor(layer: Layer): void;
+    updateVisibility(layerOrName: string | Layer, visible: boolean): void;
+    setQuarantinedLayerNames(names: readonly string[]): void;
+    /** Name lookup for {@link isLayerQuarantined}, which every visibility read and write consults. */
+    private get quarantinedNames();
+    isLayerQuarantined(layerOrName: Layer | string): boolean;
+    setLayerVisibility(layer: Layer, visible: boolean): void;
+    private notifyFloorActivated;
+    findLayer(z: string | number | null | undefined): Layer | null;
+    getPathwayList(): Layer[];
+    showPathWay(name: string): Promise<void>;
+    hidePathways(): void;
+}
+//# sourceMappingURL=LayerStore.d.ts.map

package/dist/esm/store/LayerStore.js

@@ -0,0 +1,399 @@
+import { __decorate } from "tslib";
+// @ts-nocheck
+import { Box } from '@expofp/geometry';
+import { action, computed, observable, runInAction } from 'mobx';
+import loadLayer from '../components/Map/drawing/config/config-load-layer';
+import { getFpSvgJs } from '../data/fp-payloads';
+import settings from '../tools/settings';
+import { areLayersEnabled } from '../utils/areLayersEnabled';
+import { shortenName } from '../utils/shortenName';
+import store from '.';
+import { createFloorActivatedNotifier } from './floor-activated-notifier';
+const VIEWBOX_EXPOS = [
+    'money2020usa',
+    'rodion2',
+    'possible2025',
+    '2025virtuosotravelweek',
+    'zscalerskofy26',
+    'gamescom2025',
+];
+export var LayersMode;
+(function (LayersMode) {
+    LayersMode[LayersMode["Default"] = 0] = "Default";
+    LayersMode[LayersMode["Separated"] = 1] = "Separated";
+    LayersMode[LayersMode["Radio"] = 2] = "Radio";
+    LayersMode[LayersMode["CheckBox"] = 3] = "CheckBox";
+})(LayersMode || (LayersMode = {}));
+export var LayerMode;
+(function (LayerMode) {
+    LayerMode[LayerMode["Unset"] = 0] = "Unset";
+    LayerMode[LayerMode["AlwaysVisible"] = 1] = "AlwaysVisible";
+    LayerMode[LayerMode["AlwaysHidden"] = 2] = "AlwaysHidden";
+    LayerMode[LayerMode["TurnedOn"] = 3] = "TurnedOn";
+    LayerMode[LayerMode["TurnedOff"] = 4] = "TurnedOff";
+})(LayerMode || (LayerMode = {}));
+export class Layer {
+    constructor() {
+        this.basePriority = 0;
+        this.name = '';
+        this.description = '';
+        this.frozen = false;
+        this.rect = null;
+        this.viewbox = null;
+        this.configured = false;
+        this.childLayers = [];
+        this.rootParent = null;
+        this.mode = LayerMode.Unset;
+        this.children = [];
+        this.loaded = false;
+        this.visible = false;
+    }
+    get shortName() {
+        return shortenName(this.description);
+    }
+}
+__decorate([
+    observable
+], Layer.prototype, "loaded", void 0);
+__decorate([
+    observable
+], Layer.prototype, "visible", void 0);
+export default class LayerStore {
+    constructor(rootStore) {
+        this.layers = [];
+        this.mode = LayersMode.Default;
+        this.layersLoaded = false;
+        this.quarantinedLayerNames = [];
+        this.selectFloorTimeout = 0;
+        this.floorActivatedNotifier = createFloorActivatedNotifier();
+        this.rootStore = rootStore;
+    }
+    get visible() {
+        return this.layers.filter((l) => !this.isLayerQuarantined(l) && (l.frozen || l.visible));
+    }
+    get loaded() {
+        return this.layers.filter((l) => l.loaded);
+    }
+    get rectangle() {
+        const boxes = this.visible
+            .filter((l) => !l.frozen)
+            .map((l) => l.viewbox ?? l.rect)
+            .filter((box) => !!box);
+        return this.mode !== LayersMode.Radio || !boxes.length ? null : Box.fromUnion(...boxes) || null;
+    }
+    /** Union of all layers' rects to use as a bounds for camera */
+    get bounds() {
+        const l = this.visible.map((l) => l.viewbox ?? l.rect).filter(Boolean);
+        return l.length ? Box.fromUnion(...l) : undefined;
+    }
+    // Union of the explicitly authored per-layer viewboxes (the Designer's
+    // "layer viewbox" tool, `data-layer-viewbox`) for the currently visible
+    // levels. This is the deterministic, author-drawn venue rectangle. Returns
+    // null when no visible level has an authored viewbox, so callers fall back
+    // to the scene-derived fit. Unlike `rectangle` it is not gated to Radio mode
+    // and never substitutes a layer's geometry `rect` for a missing viewbox.
+    get viewboxRectangle() {
+        const boxes = this.visible
+            .filter((l) => !l.frozen)
+            .map((l) => l.viewbox)
+            .filter((box) => !!box);
+        return boxes.length ? Box.fromUnion(...boxes) || null : null;
+    }
+    get pathwayLayers() {
+        return this.layers.filter((l) => l.pathway && !this.isLayerQuarantined(l));
+    }
+    get venueLayers() {
+        // Venue aux-referenced layers are degraded-appearance artwork (venue zoom
+        // degradation), never floors — whatever their other flags say.
+        const aux = store.venueStore?.auxVenuesByLayerName;
+        return this.layers.filter((l) => l &&
+            !this.isLayerQuarantined(l) &&
+            !l.frozen &&
+            !l.rootParent &&
+            !l.pathway &&
+            !aux?.has(l.name));
+    }
+    get floors() {
+        if (!areLayersEnabled()) {
+            return [];
+        }
+        const venueStore = store.venueStore;
+        if (venueStore?.hasVenueModel && !venueStore.isCampusMode) {
+            const venue = venueStore.fallbackVenue;
+            if (!venue)
+                return [];
+            const levels = [...venue.levels].reverse();
+            return levels.map((level) => ({
+                layer: level.layer,
+                name: level.layer.name,
+                shortName: level.layer.shortName,
+                description: level.displayName,
+                active: level === venue.activeLevel,
+                disabled: false,
+                index: level.layer.floorIndex ?? level.ordinal,
+            }));
+        }
+        const uniqueLayers = new Set(this.venueLayers.concat(store.routeStore.layers.filter((l) => l &&
+            !this.isLayerQuarantined(l) &&
+            l.mode !== LayerMode.AlwaysHidden &&
+            l.mode !== LayerMode.AlwaysVisible)));
+        const venueMode = !!venueStore?.hasVenueModel;
+        const arr = Array.from(uniqueLayers).reverse();
+        return arr.map((l, index) => {
+            // In venue mode a route inside one venue must not disable the other
+            // venues' switch entries — the switch only moves the camera.
+            const hasRouteRestriction = !venueMode &&
+                store.routeStore.layers.length > 0 &&
+                store.routeStore.layers.indexOf(l) === -1;
+            const hasTourRestriction = store.toursStore.tourLayers.length > 0 && store.toursStore.tourLayers.indexOf(l) === -1;
+            return {
+                layer: l,
+                name: l.name,
+                shortName: l.shortName,
+                description: l.description,
+                active: l.visible,
+                disabled: Boolean(hasRouteRestriction || hasTourRestriction),
+                index: l.floorIndex ?? arr.length - index - 1,
+            };
+        });
+    }
+    selectFloor(layer) {
+        if (this.selectFloorTimeout)
+            return;
+        this.selectFloorTimeout = window.setTimeout(() => (this.selectFloorTimeout = 0), 500);
+        // Resolve by unique layer name first: descriptions are freeform display
+        // labels that repeat across venues on multi-venue plans ("1", "Ground"),
+        // and the first description match could be another venue's level.
+        const currentLayer = this.layers.find((l) => l.name === layer.name) ??
+            this.layers.find((l) => l.description === layer.description);
+        if (!currentLayer || this.isLayerQuarantined(currentLayer))
+            return;
+        if (store.venueStore?.hasVenueModel && store.venueStore.venueOfLayer(currentLayer)) {
+            store.venueStore.activateLayer(currentLayer);
+            return;
+        }
+        if (this.mode === LayersMode.Radio) {
+            this.updateVisibility(currentLayer, true);
+            if (store.maplibreStore.showMaplibre)
+                return;
+            const useViewbox = !!getFpSvgJs().__fpSettings?.fpVer || VIEWBOX_EXPOS.includes(settings.EXPO);
+            if (useViewbox) {
+                const r = currentLayer.viewbox ?? currentLayer.rect;
+                store.uiState.moveToRect = r;
+            }
+            else {
+                const i1 = this.layers.indexOf(this.layers.filter((l) => !l.frozen && l.visible)[0]);
+                const i2 = this.layers.indexOf(currentLayer);
+                if (i1 === i2)
+                    return;
+                store.uiState.zoomBy = i2 < i1 ? 0.95 : 1.05;
+            }
+        }
+        else {
+            this.updateVisibility(currentLayer, !currentLayer.visible);
+        }
+        const tourLayerInfo = store.toursStore.getTourLayerInfo(currentLayer.name) ||
+            store.toursStore.getTourLayerInfo(currentLayer.description);
+        if (tourLayerInfo) {
+            this.showPathWay(tourLayerInfo.id);
+            return;
+        }
+        store.toursStore.stopTour();
+    }
+    updateVisibility(layerOrName, visible) {
+        const layer = layerOrName instanceof Layer ? layerOrName : this.findLayer(layerOrName);
+        if (layer && this.isLayerQuarantined(layer)) {
+            this.setLayerVisibility(layer, false);
+            return;
+        }
+        // Venue-model plans (data.venues): level activation is venue-scoped Radio,
+        // owned by VenueStore. Hide requests and non-venue layers never trigger
+        // cross-venue hiding.
+        if (store.venueStore?.hasVenueModel) {
+            if (!visible || !layer)
+                return;
+            if (store.venueStore.venueOfLayer(layer)) {
+                store.venueStore.activateLayer(layer);
+            }
+            else if (!layer.visible) {
+                // Technical layer outside any venue: plain show, no Radio side effects.
+                loadLayer(layer).then(() => this.setLayerVisibility(layer, true));
+            }
+            return;
+        }
+        if (this.mode === LayersMode.Radio && !visible)
+            return;
+        if (!layer || layer.visible === visible) {
+            if (layer && store.routeStore.currentRouteLayer !== layer) {
+                store.routeStore.currentRouteLayer = layer;
+            }
+            return;
+        }
+        loadLayer(layer).then(() => {
+            if (this.mode === LayersMode.Radio) {
+                this.layers
+                    .filter((l) => !l.pathway)
+                    .forEach((l) => {
+                    if (l.name !== layer.name && !l.frozen && l.visible) {
+                        l.visible = false;
+                        l.childLayers.forEach((child) => {
+                            child.visible = false;
+                        });
+                    }
+                });
+            }
+            if (layer) {
+                this.setLayerVisibility(layer, visible);
+                if (visible)
+                    store.routeStore.currentRouteLayer = layer;
+                this.notifyFloorActivated(layer);
+            }
+        });
+    }
+    setQuarantinedLayerNames(names) {
+        this.quarantinedLayerNames = Array.from(new Set(names));
+        this.layers.forEach((layer) => {
+            if (this.isLayerQuarantined(layer))
+                this.setLayerVisibility(layer, false);
+        });
+    }
+    /** Name lookup for {@link isLayerQuarantined}, which every visibility read and write consults. */
+    get quarantinedNames() {
+        return new Set(this.quarantinedLayerNames);
+    }
+    isLayerQuarantined(layerOrName) {
+        // Quarantine is the rare error path, so keep the common case to one check
+        // and skip the `layers.find` a string argument would otherwise cost.
+        const quarantined = this.quarantinedNames;
+        if (quarantined.size === 0)
+            return false;
+        if (typeof layerOrName !== 'string') {
+            return ((!!layerOrName?.name && quarantined.has(layerOrName.name)) ||
+                (!!layerOrName?.rootParent?.name && quarantined.has(layerOrName.rootParent.name)));
+        }
+        if (quarantined.has(layerOrName))
+            return true;
+        // Only a quarantined root parent is left to check, so resolve the layer now.
+        const rootParentName = this.layers.find((candidate) => candidate.name === layerOrName)
+            ?.rootParent?.name;
+        return !!rootParentName && quarantined.has(rootParentName);
+    }
+    setLayerVisibility(layer, visible) {
+        const effectiveVisible = visible && !this.isLayerQuarantined(layer);
+        layer.visible = effectiveVisible;
+        layer.childLayers.forEach((child) => {
+            child.visible = effectiveVisible;
+        });
+    }
+    notifyFloorActivated(layer) {
+        this.floorActivatedNotifier(store.fp, layer.name);
+    }
+    findLayer(z) {
+        if (z === null || z === undefined)
+            return null;
+        const layers = this.layers.filter((l) => !l.rootParent);
+        if (typeof z === 'number') {
+            const atIndex = layers.filter((k) => !k.frozen)[z];
+            if (atIndex)
+                return atIndex;
+        }
+        const key = z.toString().toLowerCase();
+        const named = layers.find((l) => {
+            const extractedNumber = (l.name.match(/(-?[0-9]+)/) || '')[0];
+            return (key === l?.name.toLowerCase() ||
+                key === l?.description.toLowerCase() ||
+                key === l?.shortName.toLowerCase() ||
+                key === extractedNumber);
+        });
+        if (named)
+            return named;
+        if (/\D/.test(key))
+            return null;
+        return layers.filter((k) => !k.frozen)[parseInt(key)] ?? null;
+    }
+    getPathwayList() {
+        return this.pathwayLayers;
+    }
+    async showPathWay(name) {
+        try {
+            const layer = this.findLayer(name);
+            if (!layer || this.isLayerQuarantined(layer)) {
+                throw new Error(`There is no pathway with this name. ${name}`);
+            }
+            await loadLayer(layer);
+            const pathways = this.getPathwayList();
+            runInAction(() => {
+                pathways.forEach((l) => {
+                    const visible = l.name === name;
+                    this.setLayerVisibility(l, visible);
+                });
+            });
+        }
+        catch (error) {
+            console.error('showPathWay', error);
+        }
+    }
+    hidePathways() {
+        const pathways = this.getPathwayList();
+        pathways.forEach((l) => {
+            this.setLayerVisibility(l, false);
+        });
+    }
+}
+__decorate([
+    observable
+], LayerStore.prototype, "layers", void 0);
+__decorate([
+    observable
+], LayerStore.prototype, "defaultLayer", void 0);
+__decorate([
+    observable
+], LayerStore.prototype, "mode", void 0);
+__decorate([
+    observable
+], LayerStore.prototype, "layersLoaded", void 0);
+__decorate([
+    observable
+], LayerStore.prototype, "quarantinedLayerNames", void 0);
+__decorate([
+    computed({ keepAlive: true })
+], LayerStore.prototype, "visible", null);
+__decorate([
+    computed({ keepAlive: true })
+], LayerStore.prototype, "loaded", null);
+__decorate([
+    computed({ keepAlive: true })
+], LayerStore.prototype, "rectangle", null);
+__decorate([
+    computed({ keepAlive: true })
+], LayerStore.prototype, "bounds", null);
+__decorate([
+    computed({ keepAlive: true })
+], LayerStore.prototype, "viewboxRectangle", null);
+__decorate([
+    computed
+], LayerStore.prototype, "pathwayLayers", null);
+__decorate([
+    computed
+], LayerStore.prototype, "venueLayers", null);
+__decorate([
+    computed
+], LayerStore.prototype, "floors", null);
+__decorate([
+    action
+], LayerStore.prototype, "selectFloor", null);
+__decorate([
+    action
+], LayerStore.prototype, "updateVisibility", null);
+__decorate([
+    action
+], LayerStore.prototype, "setQuarantinedLayerNames", null);
+__decorate([
+    computed
+], LayerStore.prototype, "quarantinedNames", null);
+__decorate([
+    action
+], LayerStore.prototype, "showPathWay", null);
+__decorate([
+    action
+], LayerStore.prototype, "hidePathways", null);