@expofp/floorplan 0.0.0-experimental.2632d13

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

@@ -0,0 +1,56 @@
+import { Booth } from './BoothStore';
+import { EventItem } from './EventStore';
+import { Exhibitor } from './ExhibitorStore';
+import RootStore from './RootStore';
+import type { RouteOption } from './types';
+export type PlannerSource = 'bookmarks' | 'custom';
+export interface PlannerItem {
+    type: 'exhibitor' | 'event' | 'booth';
+    entity: Exhibitor | EventItem | Booth;
+    booth: Booth | null;
+}
+export default class RoutePlannerStore {
+    rootStore: RootStore;
+    items: PlannerItem[];
+    startPoint: Booth | null;
+    source: PlannerSource | null;
+    excludedVisitedCount: number;
+    constructor(rootStore: RootStore);
+    get resolvedBooths(): Booth[];
+    get stopsCount(): number;
+    get startPointBoothOptions(): Booth[];
+    get startPointAutocompleteOptions(): RouteOption[];
+    get title(): string;
+    get subtitleParts(): {
+        stops: string;
+        from: string | undefined;
+        distance: string | undefined;
+        travelTime: string | undefined;
+    };
+    get routeFloors(): {
+        id: number;
+        name: string;
+        description?: string;
+        directionToNext?: 'up' | 'down';
+    }[];
+    get currentRouteFloor(): {
+        id: number;
+        name: string;
+    } | undefined;
+    setRouteFloor(floor: {
+        id: number;
+        name: string;
+    }): void;
+    launch(items: PlannerItem[], source?: PlannerSource, initialStartPoint?: Booth | null): void;
+    launchFromBookmarks(initialStartPoint?: Booth | null): void;
+    launchFromSlugs(slugs: string[], initialStartPoint?: Booth | null): void;
+    private resolveSlugs;
+    buildRoute(): void;
+    private reorderItemsByNames;
+    private detectStartPoint;
+    setStartPoint(booth: Booth | null): void;
+    removeItem(index: number): void;
+    reorderItems(fromIndex: number, toIndex: number): void;
+    close(): void;
+}
+//# sourceMappingURL=RoutePlannerStore.d.ts.map

package/dist/esm/store/RoutePlannerStore.js

@@ -0,0 +1,322 @@
+/* eslint-disable @typescript-eslint/consistent-type-imports */
+import { __decorate } from "tslib";
+// @ts-nocheck
+import { action, computed, observable } from 'mobx';
+import { t } from '../utils/i18n';
+import { findBooth, Route } from './RouteStore';
+export default class RoutePlannerStore {
+    constructor(rootStore) {
+        this.items = [];
+        this.startPoint = null;
+        this.source = null;
+        this.excludedVisitedCount = 0;
+        this.rootStore = rootStore;
+    }
+    get resolvedBooths() {
+        const uniqueBooths = new Map();
+        if (this.startPoint) {
+            uniqueBooths.set(this.startPoint.id, this.startPoint);
+        }
+        this.items.forEach((item) => {
+            if (item.booth) {
+                uniqueBooths.set(item.booth.id, item.booth);
+            }
+        });
+        return Array.from(uniqueBooths.values());
+    }
+    get stopsCount() {
+        return this.items.length;
+    }
+    get startPointBoothOptions() {
+        return this.rootStore.boothStore.booths;
+    }
+    get startPointAutocompleteOptions() {
+        const { exhibitorStore } = this.rootStore;
+        const allBooths = this.startPointBoothOptions;
+        const optionsList = [];
+        const usedBoothIds = new Set();
+        exhibitorStore.exhibitors.forEach((exhibitor) => {
+            exhibitor.booths.forEach((booth) => {
+                usedBoothIds.add(booth.id);
+                optionsList.push({
+                    value: booth.id.toString(),
+                    label: `${exhibitor.name} - ${booth.name}`,
+                    exhibitorId: exhibitor.id,
+                });
+            });
+        });
+        const remainingBooths = allBooths.filter((booth) => !usedBoothIds.has(booth.id));
+        remainingBooths.forEach((booth) => {
+            optionsList.push({ value: booth.id.toString(), label: booth.name });
+        });
+        return optionsList.sort((a, b) => a.label.localeCompare(b.label, undefined, { sensitivity: 'base' }));
+    }
+    get title() {
+        return this.source === 'bookmarks' ? t('Bookmarks route') : '';
+    }
+    get subtitleParts() {
+        const { routeInfo } = this.rootStore.routeStore;
+        let travelTime;
+        if (routeInfo?.time) {
+            const seconds = routeInfo.time;
+            travelTime = seconds < 60 ? t('< 1 min') : t('~ {{n}} min', { n: Math.round(seconds / 60) });
+        }
+        return {
+            stops: t('{{count}} stops', { count: this.stopsCount }),
+            from: this.startPoint ? t('From {{name}}', { name: this.startPoint.name }) : undefined,
+            distance: routeInfo ? routeInfo.distance : undefined,
+            travelTime,
+        };
+    }
+    get routeFloors() {
+        const layers = this.rootStore.routeStore.pathLayers;
+        return layers.map((l, i) => {
+            const next = layers[i + 1];
+            const currentPriority = l.layer?.basePriority ?? 0;
+            const nextPriority = next?.layer?.basePriority ?? 0;
+            const directionToNext = next
+                ? nextPriority < currentPriority
+                    ? 'up'
+                    : 'down'
+                : undefined;
+            return {
+                id: l.id,
+                name: l.layer?.shortName,
+                description: l.layer?.description,
+                directionToNext,
+            };
+        });
+    }
+    get currentRouteFloor() {
+        const floors = this.routeFloors;
+        const current = this.rootStore.routeStore.currentRouteLayer;
+        if (!floors.length)
+            return undefined;
+        if (!current)
+            return floors[0] ? { id: floors[0].id, name: floors[0].name } : undefined;
+        const match = floors.find((f) => f.description?.toLowerCase() === current.description?.toLowerCase());
+        return match ? { id: match.id, name: match.name } : { id: floors[0].id, name: floors[0].name };
+    }
+    setRouteFloor(floor) {
+        const entry = this.rootStore.routeStore.pathLayers.find((l) => l.id === floor.id);
+        if (!entry?.layer)
+            return;
+        this.rootStore.layerStore.updateVisibility(entry.layer, true);
+    }
+    launch(items, source = 'custom', initialStartPoint) {
+        this.excludedVisitedCount = items.filter((item) => item.type === 'exhibitor' && item.entity.visited).length;
+        this.items = items.filter((item) => {
+            if (item.type === 'exhibitor') {
+                return !item.entity.visited;
+            }
+            return true;
+        });
+        this.source = source;
+        this.startPoint = initialStartPoint !== undefined ? initialStartPoint : this.detectStartPoint();
+        const { uiState } = this.rootStore;
+        uiState.list = { type: 'route-planner', source: source };
+        uiState.details = null;
+        uiState.menu = false;
+        this.buildRoute();
+    }
+    launchFromBookmarks(initialStartPoint) {
+        const { exhibitorStore, eventStore, boothStore } = this.rootStore;
+        const items = [];
+        exhibitorStore.bookmarked.forEach((e) => {
+            // Note: exhibitors may have multiple booths. For bookmark-based routes we
+            // currently use the first booth in `e.booths` as the representative booth.
+            // If multi-booth routing needs to be supported, this selection logic should
+            // be revisited (e.g. user choice or an explicit primary-booth rule).
+            items.push({ type: 'exhibitor', entity: e, booth: e.booths[0] || null });
+        });
+        boothStore.booths
+            .filter((b) => b.exhibitors.length === 0 && b.bookmarkedDirectly)
+            .forEach((b) => {
+            items.push({ type: 'booth', entity: b, booth: b });
+        });
+        this.launch(items, 'bookmarks', initialStartPoint);
+    }
+    launchFromSlugs(slugs, initialStartPoint) {
+        const items = this.resolveSlugs(slugs);
+        this.launch(items, 'custom', initialStartPoint);
+    }
+    resolveSlugs(slugs) {
+        const { exhibitorStore, eventStore, boothStore } = this.rootStore;
+        return slugs
+            .filter(Boolean)
+            .map((slug) => {
+            const lowerSlug = slug.toLowerCase();
+            const exhibitor = exhibitorStore.exhibitors.find((e) => e.slug?.toLowerCase() === lowerSlug || e.externalId?.toLowerCase() === lowerSlug);
+            if (exhibitor) {
+                return {
+                    type: 'exhibitor',
+                    entity: exhibitor,
+                    booth: exhibitor.booths[0] || null,
+                };
+            }
+            const booth = findBooth(slug);
+            if (booth) {
+                return { type: 'booth', entity: booth, booth };
+            }
+            return null;
+        })
+            .filter((item) => item !== null);
+    }
+    buildRoute() {
+        const names = [];
+        if (this.startPoint && this.startPoint.name)
+            names.push(this.startPoint.name);
+        this.items.forEach((item) => {
+            if (item.booth && item.booth.name)
+                names.push(item.booth.name);
+        });
+        if (names.length < 2) {
+            this.rootStore.routeStore.updateRoute([]);
+            return;
+        }
+        let optimizedNames;
+        try {
+            const routes = this.rootStore.fp?.getOptimizedRoutes?.(names);
+            optimizedNames = Array.isArray(routes)
+                ? routes.flatMap((r) => r?.waypoints ?? [])
+                : [];
+        }
+        catch {
+            optimizedNames = [];
+        }
+        const uniqueInputNames = new Set(names);
+        const optimizedSet = new Set(optimizedNames);
+        const hasAllNames = names.length > 0 && [...uniqueInputNames].every((n) => optimizedSet.has(n));
+        if (!optimizedNames.length || !hasAllNames) {
+            optimizedNames = names.slice();
+        }
+        this.reorderItemsByNames(optimizedNames);
+        const booths = this.resolvedBooths;
+        if (booths.length < 2) {
+            this.rootStore.routeStore.updateRoute([]);
+            return;
+        }
+        const from = booths[0];
+        const to = booths[booths.length - 1];
+        const waypoints = booths.slice(1, -1);
+        const route = new Route(from, to, waypoints);
+        this.rootStore.routeStore.selectRoute(route, false);
+        this.rootStore.uiState.setIsMultiPointRoute(waypoints.length > 0);
+    }
+    reorderItemsByNames(optimizedNames) {
+        const startName = this.startPoint ? this.startPoint.name : null;
+        const boothMap = new Map();
+        this.items.forEach((item) => {
+            const name = item.booth ? item.booth.name : null;
+            if (name) {
+                if (!boothMap.has(name))
+                    boothMap.set(name, []);
+                boothMap.get(name).push(item);
+            }
+        });
+        const reordered = [];
+        optimizedNames.forEach((name) => {
+            if (name !== startName) {
+                const group = boothMap.get(name);
+                if (group && group.length > 0) {
+                    reordered.push(...group.splice(0));
+                }
+            }
+        });
+        this.items = reordered;
+    }
+    detectStartPoint() {
+        const { boothStore, poiTypeStore } = this.rootStore;
+        const entranceNames = ['entrance', 'entrances'];
+        const entranceType = poiTypeStore.poiTypes.find((pt) => entranceNames.includes(pt.name.toLowerCase()));
+        if (entranceType) {
+            return boothStore.booths.find((b) => b.poiTypeId === entranceType.id) || null;
+        }
+        return null;
+    }
+    setStartPoint(booth) {
+        this.startPoint = booth;
+        this.buildRoute();
+    }
+    removeItem(index) {
+        this.items.splice(index, 1);
+        this.buildRoute();
+    }
+    reorderItems(fromIndex, toIndex) {
+        const [removed] = this.items.splice(fromIndex, 1);
+        this.items.splice(toIndex, 0, removed);
+        this.buildRoute();
+    }
+    close() {
+        this.items = [];
+        this.startPoint = null;
+        this.source = null;
+        this.excludedVisitedCount = 0;
+        this.rootStore.uiState.details = null;
+        this.rootStore.uiState.list = { type: 'search', text: '', focused: false };
+        this.rootStore.routeStore.selectRoute(null, false);
+    }
+}
+__decorate([
+    observable
+], RoutePlannerStore.prototype, "items", void 0);
+__decorate([
+    observable
+], RoutePlannerStore.prototype, "startPoint", void 0);
+__decorate([
+    observable
+], RoutePlannerStore.prototype, "source", void 0);
+__decorate([
+    observable
+], RoutePlannerStore.prototype, "excludedVisitedCount", void 0);
+__decorate([
+    computed
+], RoutePlannerStore.prototype, "resolvedBooths", null);
+__decorate([
+    computed
+], RoutePlannerStore.prototype, "stopsCount", null);
+__decorate([
+    computed
+], RoutePlannerStore.prototype, "startPointBoothOptions", null);
+__decorate([
+    computed
+], RoutePlannerStore.prototype, "startPointAutocompleteOptions", null);
+__decorate([
+    computed
+], RoutePlannerStore.prototype, "title", null);
+__decorate([
+    computed
+], RoutePlannerStore.prototype, "subtitleParts", null);
+__decorate([
+    computed
+], RoutePlannerStore.prototype, "routeFloors", null);
+__decorate([
+    computed
+], RoutePlannerStore.prototype, "currentRouteFloor", null);
+__decorate([
+    action
+], RoutePlannerStore.prototype, "setRouteFloor", null);
+__decorate([
+    action
+], RoutePlannerStore.prototype, "launch", null);
+__decorate([
+    action
+], RoutePlannerStore.prototype, "launchFromBookmarks", null);
+__decorate([
+    action
+], RoutePlannerStore.prototype, "launchFromSlugs", null);
+__decorate([
+    action
+], RoutePlannerStore.prototype, "buildRoute", null);
+__decorate([
+    action
+], RoutePlannerStore.prototype, "setStartPoint", null);
+__decorate([
+    action
+], RoutePlannerStore.prototype, "removeItem", null);
+__decorate([
+    action
+], RoutePlannerStore.prototype, "reorderItems", null);
+__decorate([
+    action
+], RoutePlannerStore.prototype, "close", null);

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

@@ -0,0 +1,138 @@
+import { type ArbitraryPoint, type RouteLine } from '../wayfinding';
+import { type Booth } from './BoothStore';
+import type { Exhibitor } from './ExhibitorStore';
+import { type Layer } from './LayerStore';
+import type RootStore from './RootStore';
+export default class RouteStore {
+    rootStore: RootStore;
+    cpTimeout: number | undefined;
+    routeLines: RouteLine[];
+    private readonly routedRouteBox;
+    /** The layers the route's campus-graph legs run on (see `routeSteps`). */
+    private readonly campusLayersBox;
+    routeDistance: number | null;
+    currentPosition: CurrentPosition | null;
+    requestCompass: boolean;
+    iconType: number;
+    tempToBooth: Booth | null;
+    focusEnabled: boolean;
+    prevZ: string | null;
+    markersData: MarkersData;
+    prevMarkers: Marker[];
+    /** Cancels the camera move still waiting for a floor to come on screen (see `revealLayer`). */
+    private pendingReveal;
+    showAccessible: boolean;
+    onlyAccessible: boolean;
+    currentRouteLayer: Layer | null;
+    currentRouteExhibitor: Exhibitor | null;
+    private selectRouteRequest;
+    constructor(rootStore: RootStore);
+    get canFindLocation(): boolean;
+    selectRoute(route: Route | null, resetList?: boolean, immediate?: boolean): void;
+    /** Rebuilds the current route with the live position as FROM, applied immediately (no 200ms defer) */
+    rebuildRouteFromPosition(newFrom: ArbitraryPoint): void;
+    /** Default FROM for `selectRoute` when only TO is given. Priority: CP > kiosk anchor > none. */
+    private resolveFallbackFrom;
+    setStartPoint(booth: Booth): void;
+    get pathLayers(): {
+        id: number;
+        layer: Layer | null;
+    }[];
+    /**
+     * Used only by the SDK `getBooth(RouteWaypoint)` path for coord-form
+     * waypoints (`floorplan.ready.tsx`). Internal callers prefer
+     * `toArbitraryPoint(currentPosition, ...)` — graph snap happens inside the
+     * engine, no booth proxy needed.
+     */
+    getNearestBooth(position: CurrentPosition): Booth | null;
+    setMarkers(data: MarkersData): void;
+    selectMarker(id: string, focus: boolean): Promise<void>;
+    get selectedMarkers(): Marker[];
+    get layers(): Layer[];
+    clickRoute(from: Booth, to: Booth): void;
+    selectCurrentPosition(point: CurrentPosition | null, focus?: boolean, icon?: number): void;
+    findLocation(): void;
+    /** The dot, plus — when it lies outside the drawing — enough of the nearest map edge for context. */
+    private findLocationRect;
+    /**
+     * Focus for a position update (first fix, or the dot changing floor): bring
+     * its floor on screen, then move the camera onto it keeping the zoom —
+     * `panTo` in the floor plan renderer; under MapLibre the renderer camera is
+     * an external-mode no-op stub, so the move goes through the adapter's
+     * `moveToLocation` reaction instead (which zooms in when a venue floor needs
+     * it to show indoor detail). Waits for the floor to be visible first
+     * (see `revealLayer`).
+     */
+    private focusOnPosition;
+    routeUnits: string;
+    get routeInfo(): {
+        distance: string;
+        units: string;
+        time: number;
+    } | null;
+    /**
+     * The route the wayfinding engine last routed — the one `routeLines` describe.
+     * A route is selected before the engine routes it, so until this matches
+     * `uiState.selectedRoute` the lines on hand say nothing about the selected pair.
+     */
+    get routedRoute(): Route | null;
+    markRouted(route: Route | null): void;
+    updateRoute(routeLines: RouteLine[], campusLayers?: readonly string[]): void;
+    updateRouteDistance(distance: number): void;
+    updateRoutePoints(): void;
+    checkRoutes(): void;
+    isGpsTrackingEnabled: boolean;
+    setGpsTrackingEnabled(value: boolean): void;
+    get gpsEnabled(): boolean;
+    setOnlyAccessible(value: boolean): void;
+}
+/**
+ * A route endpoint's layer NAME: a booth carries the `Layer` object, an
+ * `ArbitraryPoint` carries the name already.
+ */
+export declare function getLayerName(endpoint: Booth | ArbitraryPoint | null | undefined): string | undefined;
+export declare function findBooth(str: string): Booth | undefined;
+export declare function findEntityByExternalId(externalId: string): {
+    type: 'booth' | 'exhibitor';
+    entity: Booth | Exhibitor;
+} | undefined;
+export declare function separateExternalIds(externalIds: string[]): {
+    boothExternalIds: string[];
+    exhibitorExternalIds: string[];
+};
+export declare function extractRoute(from: string, to: string, waypoints: string[]): Route;
+export declare class Route {
+    from: Booth | ArbitraryPoint | null;
+    to: Booth | ArbitraryPoint | null;
+    waypoints?: Booth[] | undefined;
+    constructor(from: Booth | ArbitraryPoint | null, to: Booth | ArbitraryPoint | null, waypoints?: Booth[] | undefined);
+}
+/** Where the blue dot is: plan coordinates, the floor it sits on, and the bearing it faces. */
+export declare class CurrentPosition {
+    x: number;
+    y: number;
+    z?: number | string | undefined;
+    angle?: number | undefined;
+    lat?: number | undefined;
+    lng?: number | undefined;
+    constructor(x: number, y: number, z?: number | string | undefined, angle?: number | undefined, lat?: number | undefined, lng?: number | undefined);
+}
+export interface Marker extends CurrentPosition {
+    id: string;
+    icon: string;
+    selectedIcon: string;
+    position: 'centertop' | 'lefttop' | 'centerbottom';
+    active?: boolean;
+}
+export interface MarkerIcon {
+    name: string;
+    content: string;
+    width: number;
+    height: number;
+    scale?: number;
+}
+export interface MarkersData {
+    icons: MarkerIcon[];
+    markers: Marker[];
+}
+//# sourceMappingURL=RouteStore.d.ts.map