@expofp/floorplan 0.0.0-experimental.2632d13

package/dist/esm/components/Maplibre/utils/geo-config.d.ts

@@ -0,0 +1,92 @@
+import { type Box } from '@expofp/geometry';
+import { type LngLatBoundsLike, type Map as MaplibreMap } from 'maplibre-gl';
+import { type GeoConfig as MaplibreGeoConfig } from '../MaplibreWrapper';
+import { type TransformGeoConfig } from './solver';
+export interface GeoConfig extends MaplibreGeoConfig {
+    gpsConfig: TransformGeoConfig;
+    /** The bearing that stands the plan upright; `bearing` is the home one. */
+    uprightBearing: number;
+    /** `enableExperimentalNorthUp`: home faces north, venues their own viewbox. */
+    northUp: boolean;
+}
+export interface CameraPaddingOptions {
+    top: number;
+    bottom: number;
+    left: number;
+    right: number;
+}
+export interface FitMapOptions {
+    duration?: number;
+    /** Floor for the resulting zoom, so a fit may not end up further out than this. */
+    minZoom?: number;
+    /** The bearing to frame the rect at, instead of the home bearing. */
+    bearing?: number;
+    /**
+     * Breathing room around the rect, in CSS pixels per side. A margin meant as a share of the
+     * framing region is grown into the rect by the caller instead (the `moveToRect` reaction).
+     */
+    padding?: number;
+}
+export declare const MAP_BOUNDS_PADDING_FACTOR = 3;
+export declare const MAP_BOUNDS_MIN_PADDING_DEGREES = 0.02;
+export declare const INITIAL_FIT_ZOOM_ADJUSTMENT = 0.15;
+/**
+ * Breathing room {@link fitMapToLocalRect} adds around a fit, in CSS pixels on
+ * top of the visible-rect inset. Exported so the initial bounds-based fit can
+ * reproduce a later `fitMapToLocalRect` exactly rather than approximate it.
+ */
+export declare const DEFAULT_FIT_PADDING = 50;
+/**
+ * The fit padding for a whole-campus frame, on top of the visible-rect inset:
+ * none for an authored campus viewbox, which is the framing and is shown as-is
+ * (the `fitRectIsFraming` rule), and {@link DEFAULT_FIT_PADDING} for the bare
+ * footprint union. The initial fit and "View all venues" both take it from
+ * here, so they land on the same camera.
+ */
+export declare function campusFitPadding(authored: boolean): number;
+/** Holds a requested zoom inside the map's own configured zoom range. */
+export declare function clampZoom(map: MaplibreMap, zoom: number): number;
+export declare function deriveVenueMapBounds(config: TransformGeoConfig): LngLatBoundsLike | undefined;
+export declare function getLocalRectGeoBounds(rect: Box, config: TransformGeoConfig): LngLatBoundsLike;
+/** Viewport a camera has to frame a rect inside, in CSS pixels. */
+export interface ViewportPx {
+    width: number;
+    height: number;
+}
+/**
+ * The camera that frames a plan-local rect exactly, with the map rotated to the
+ * plan's bearing.
+ *
+ * Deliberately *not* `map.cameraForBounds`. A `LngLatBounds` is north-aligned,
+ * so a rect on a rotated plan can only reach MapLibre as its geographic AABB —
+ * and `cameraForBounds` then fits the AABB's north-west→south-east *diagonal*
+ * re-rotated into the bearing-aligned frame, a box with no relation to the rect
+ * once the bearing is not a multiple of 90°. At a -48.8° bearing a 1159x814
+ * plan rect reaches the fit as roughly 45x597, so the vertical constraint wins
+ * and the camera lands ~1.27 zoom levels (2.4x) too far out. Rotating the
+ * rect's own four corners before measuring is the whole fix.
+ *
+ * `zoom` pins the camera's zoom instead of fitting it; the rect's centre still
+ * lands on the centre of the padded area.
+ *
+ * Returns null when the rect, the projection or the viewport can't produce a
+ * camera; callers keep their current framing in that case.
+ */
+export declare function cameraForLocalRect(rect: Box, config: TransformGeoConfig, bearing: number, viewport: ViewportPx, padding: CameraPaddingOptions, zoom?: number): {
+    center: [number, number];
+    zoom: number;
+} | null;
+export declare function getVisibleRectFitPadding(extraPadding?: number, visibleRect?: Box): CameraPaddingOptions;
+/** Whether a lng/lat projects inside the visible viewport, inset by `padding`. */
+export declare function isLngLatInVisibleViewport(map: MaplibreMap, lngLat: [number, number], padding: CameraPaddingOptions): boolean;
+/** Geographic configuration from fpGeo data; null when unavailable. */
+export declare function deriveGeoConfig(): GeoConfig | null;
+/**
+ * The bearing a fit into a venue level turns the map to. North-up turns it to
+ * the level's authored viewbox — upright, plus whatever turn the viewbox
+ * carries — so a building is read along its own axes while the campus around
+ * it faces north. Otherwise the home bearing, as for every other fit.
+ */
+export declare function venueLevelBearing(geoConfig: GeoConfig, layerName: string): number;
+export declare function fitMapToLocalRect(map: MaplibreMap | null, rect: Box | null, geoConfig: GeoConfig | null, options?: FitMapOptions): void;
+//# sourceMappingURL=geo-config.d.ts.map

package/dist/esm/components/Maplibre/utils/geo-config.js

@@ -0,0 +1,305 @@
+import { getConfig } from '@expofp/config';
+import { LngLatBounds, MercatorCoordinate, } from 'maplibre-gl';
+import { getFpGeo } from '../../../data/fpGeo.js';
+import { getLayerViewboxRotation } from '../../../data/layer-viewbox';
+import { getSvgArea } from '../../../data/svg.js';
+import { uiState } from '../../../store';
+import { convertLocalToGps } from '../../../utils/gps';
+import { planBearing } from '../../../utils/planBearing';
+import { framingRect } from '../../Map/framing-rect.js';
+export const MAP_BOUNDS_PADDING_FACTOR = 3;
+export const MAP_BOUNDS_MIN_PADDING_DEGREES = 0.02;
+export const INITIAL_FIT_ZOOM_ADJUSTMENT = 0.15;
+/**
+ * Breathing room {@link fitMapToLocalRect} adds around a fit, in CSS pixels on
+ * top of the visible-rect inset. Exported so the initial bounds-based fit can
+ * reproduce a later `fitMapToLocalRect` exactly rather than approximate it.
+ */
+export const DEFAULT_FIT_PADDING = 50;
+/**
+ * The fit padding for a whole-campus frame, on top of the visible-rect inset:
+ * none for an authored campus viewbox, which is the framing and is shown as-is
+ * (the `fitRectIsFraming` rule), and {@link DEFAULT_FIT_PADDING} for the bare
+ * footprint union. The initial fit and "View all venues" both take it from
+ * here, so they land on the same camera.
+ */
+export function campusFitPadding(authored) {
+    return authored ? 0 : DEFAULT_FIT_PADDING;
+}
+// MapLibre's default flyTo curve: the search ceiling, and the curve at which a
+// flight zooms out to roughly show both endpoints.
+const FLYTO_CURVE = 1.42;
+// Floor for the flyTo curve; below this the arc is barely a swoop, so ease instead.
+const MIN_SAFE_FLYTO_CURVE = 0.35;
+// Flattens every flyTo arc a notch below the safe curve; lower = flatter.
+const REDUCED_FLYTO_CURVE_FACTOR = 0.9;
+const REDUCED_FLYTO_DURATION_FACTOR = 0.85;
+const FLYTO_CURVE_SEARCH_ITERATIONS = 8;
+// How far below the map's minZoom a swoop may dip before it's rejected. Past
+// minZoom the camera flings out over uncached basemap and flashes blank, so such
+// a swoop is replaced by a plain ease.
+const SWOOP_ZOOM_EPSILON = 0.05;
+/** Holds a requested zoom inside the map's own configured zoom range. */
+export function clampZoom(map, zoom) {
+    return Math.min(Math.max(zoom, map.getMinZoom()), map.getMaxZoom());
+}
+export function deriveVenueMapBounds(config) {
+    const svgArea = getSvgArea();
+    const corners = [
+        [svgArea.min.x, svgArea.min.y],
+        [svgArea.max.x, svgArea.min.y],
+        [svgArea.max.x, svgArea.max.y],
+        [svgArea.min.x, svgArea.max.y],
+    ].map(([x, y]) => convertLocalToGps(x, y, config));
+    if (!corners.every(([lng, lat]) => Number.isFinite(lng) && Number.isFinite(lat))) {
+        return undefined;
+    }
+    const lngs = corners.map(([lng]) => lng);
+    const lats = corners.map(([, lat]) => lat);
+    const minLng = Math.min(...lngs);
+    const maxLng = Math.max(...lngs);
+    const minLat = Math.min(...lats);
+    const maxLat = Math.max(...lats);
+    const lngPadding = Math.max((maxLng - minLng) * MAP_BOUNDS_PADDING_FACTOR, MAP_BOUNDS_MIN_PADDING_DEGREES);
+    const latPadding = Math.max((maxLat - minLat) * MAP_BOUNDS_PADDING_FACTOR, MAP_BOUNDS_MIN_PADDING_DEGREES);
+    return [
+        [minLng - lngPadding, minLat - latPadding],
+        [maxLng + lngPadding, maxLat + latPadding],
+    ];
+}
+/**
+ * Whether a `map.flyTo` keeps its mid-flight zoom-out at or above the map's
+ * minZoom. A flyTo zooms out, at its widest, to roughly the both-endpoints frame
+ * (`bothZoom`) at the default curve; lower curves flatten that dip toward a plain
+ * pan. Only the deepest point of the dip matters here, since dipping below minZoom
+ * is what flashes blank.
+ */
+function estimateFlyToSafe(map, endZoom, bothZoom, curve) {
+    const endpointZoom = Math.min(map.getZoom(), endZoom);
+    // bothZoom is the wider (lower) frame, so this dip is negative; scale by curve.
+    const peakDepth = (bothZoom - endpointZoom) * Math.min(1, curve / FLYTO_CURVE);
+    const deepestZoom = endpointZoom + peakDepth;
+    return deepestZoom >= map.getMinZoom() - SWOOP_ZOOM_EPSILON;
+}
+function findSafeFlyToCurve(map, endZoom, bothZoom) {
+    if (estimateFlyToSafe(map, endZoom, bothZoom, FLYTO_CURVE))
+        return FLYTO_CURVE;
+    if (!estimateFlyToSafe(map, endZoom, bothZoom, MIN_SAFE_FLYTO_CURVE))
+        return null;
+    let low = MIN_SAFE_FLYTO_CURVE;
+    let high = FLYTO_CURVE;
+    for (let i = 0; i < FLYTO_CURVE_SEARCH_ITERATIONS; i++) {
+        const mid = (low + high) / 2;
+        if (estimateFlyToSafe(map, endZoom, bothZoom, mid)) {
+            low = mid;
+        }
+        else {
+            high = mid;
+        }
+    }
+    return low;
+}
+export function getLocalRectGeoBounds(rect, config) {
+    const corners = [
+        convertLocalToGps(rect.min.x, rect.min.y, config),
+        convertLocalToGps(rect.max.x, rect.min.y, config),
+        convertLocalToGps(rect.max.x, rect.max.y, config),
+        convertLocalToGps(rect.min.x, rect.max.y, config),
+    ];
+    const lngs = corners.map(([lng]) => lng);
+    const lats = corners.map(([, lat]) => lat);
+    return [
+        [Math.min(...lngs), Math.min(...lats)],
+        [Math.max(...lngs), Math.max(...lats)],
+    ];
+}
+/** MapLibre's tile size — the world is `TILE_SIZE * 2 ** zoom` pixels across. */
+const TILE_SIZE = 512;
+/**
+ * The camera that frames a plan-local rect exactly, with the map rotated to the
+ * plan's bearing.
+ *
+ * Deliberately *not* `map.cameraForBounds`. A `LngLatBounds` is north-aligned,
+ * so a rect on a rotated plan can only reach MapLibre as its geographic AABB —
+ * and `cameraForBounds` then fits the AABB's north-west→south-east *diagonal*
+ * re-rotated into the bearing-aligned frame, a box with no relation to the rect
+ * once the bearing is not a multiple of 90°. At a -48.8° bearing a 1159x814
+ * plan rect reaches the fit as roughly 45x597, so the vertical constraint wins
+ * and the camera lands ~1.27 zoom levels (2.4x) too far out. Rotating the
+ * rect's own four corners before measuring is the whole fix.
+ *
+ * `zoom` pins the camera's zoom instead of fitting it; the rect's centre still
+ * lands on the centre of the padded area.
+ *
+ * Returns null when the rect, the projection or the viewport can't produce a
+ * camera; callers keep their current framing in that case.
+ */
+export function cameraForLocalRect(rect, config, bearing, viewport, padding, zoom) {
+    const corners = [
+        convertLocalToGps(rect.min.x, rect.min.y, config),
+        convertLocalToGps(rect.max.x, rect.min.y, config),
+        convertLocalToGps(rect.max.x, rect.max.y, config),
+        convertLocalToGps(rect.min.x, rect.max.y, config),
+    ].map(([lng, lat]) => MercatorCoordinate.fromLngLat({ lng, lat }));
+    if (!corners.every(({ x, y }) => Number.isFinite(x) && Number.isFinite(y)))
+        return null;
+    // Into the bearing-aligned frame — the frame the camera actually shows, where
+    // the plan rect is axis-aligned and its extent is what has to fit.
+    const angle = (-bearing * Math.PI) / 180;
+    const cos = Math.cos(angle);
+    const sin = Math.sin(angle);
+    const xs = corners.map(({ x, y }) => x * cos - y * sin);
+    const ys = corners.map(({ x, y }) => x * sin + y * cos);
+    const width = Math.max(...xs) - Math.min(...xs);
+    const height = Math.max(...ys) - Math.min(...ys);
+    if (width <= 0 || height <= 0)
+        return null;
+    const availableWidth = viewport.width - padding.left - padding.right;
+    const availableHeight = viewport.height - padding.top - padding.bottom;
+    if (availableWidth <= 0 || availableHeight <= 0)
+        return null;
+    const scale = zoom === undefined
+        ? Math.min(availableWidth / (width * TILE_SIZE), availableHeight / (height * TILE_SIZE))
+        : 2 ** zoom;
+    if (!(scale > 0))
+        return null;
+    // Asymmetric padding moves the usable area off the canvas centre, so the
+    // camera centre steps the other way by half the imbalance.
+    const worldPx = TILE_SIZE * scale;
+    const centreX = (Math.min(...xs) + Math.max(...xs)) / 2 - (padding.left - padding.right) / 2 / worldPx;
+    const centreY = (Math.min(...ys) + Math.max(...ys)) / 2 - (padding.top - padding.bottom) / 2 / worldPx;
+    const { lng, lat } = new MercatorCoordinate(centreX * cos + centreY * sin, -centreX * sin + centreY * cos).toLngLat();
+    return { center: [lng, lat], zoom: Math.log2(scale) };
+}
+export function getVisibleRectFitPadding(extraPadding = 0, visibleRect = uiState.canvasVisibleRectPx) {
+    const screenSize = uiState.screenSize;
+    if (!visibleRect) {
+        return { top: extraPadding, bottom: extraPadding, left: extraPadding, right: extraPadding };
+    }
+    return {
+        top: Math.max(0, visibleRect.min.y) + extraPadding,
+        bottom: Math.max(0, screenSize.height - visibleRect.max.y) + extraPadding,
+        left: Math.max(0, visibleRect.min.x) + extraPadding,
+        right: Math.max(0, screenSize.width - visibleRect.max.x) + extraPadding,
+    };
+}
+/** Whether a lng/lat projects inside the visible viewport, inset by `padding`. */
+export function isLngLatInVisibleViewport(map, lngLat, padding) {
+    const point = map.project(lngLat);
+    const canvas = map.getCanvas();
+    return (point.x >= padding.left &&
+        point.x <= canvas.clientWidth - padding.right &&
+        point.y >= padding.top &&
+        point.y <= canvas.clientHeight - padding.bottom);
+}
+/** Geographic configuration from fpGeo data; null when unavailable. */
+export function deriveGeoConfig() {
+    const config = getFpGeo()?.properties?.config;
+    if (!config)
+        return null;
+    // Center = midpoint of p0 and p2.
+    const centerLng = (config.p0.lng + config.p2.lng) / 2;
+    const centerLat = (config.p0.lat + config.p2.lat) / 2;
+    // The home bearing every fit returns to. North-up faces north; otherwise the
+    // bearing that keeps the plan upright, derived from the same p0->p2 diagonal
+    // as the render transform so the two can't drift. Stored bearing is a fallback.
+    const derivedBearing = planBearing(config.p0, config.p2);
+    const uprightBearing = Number.isFinite(derivedBearing) ? derivedBearing : (config.bearing ?? 0);
+    const northUp = getConfig().enableExperimentalNorthUp === true;
+    return {
+        center: [centerLng, centerLat],
+        bearing: northUp ? 0 : uprightBearing,
+        zoom: 16,
+        gpsConfig: config,
+        uprightBearing,
+        northUp,
+    };
+}
+/**
+ * The bearing a fit into a venue level turns the map to. North-up turns it to
+ * the level's authored viewbox — upright, plus whatever turn the viewbox
+ * carries — so a building is read along its own axes while the campus around
+ * it faces north. Otherwise the home bearing, as for every other fit.
+ */
+export function venueLevelBearing(geoConfig, layerName) {
+    if (!geoConfig.northUp)
+        return geoConfig.bearing;
+    return (geoConfig.uprightBearing + getLayerViewboxRotation(layerName) + 360) % 360;
+}
+export function fitMapToLocalRect(map, rect, geoConfig, options = {}) {
+    if (!map ||
+        !rect ||
+        !geoConfig ||
+        rect.size.height === Infinity ||
+        rect.size.width === Infinity ||
+        rect.size.height <= 0 ||
+        rect.size.width <= 0)
+        return;
+    const bearing = options.bearing ?? geoConfig.bearing;
+    const bounds = getLocalRectGeoBounds(rect, geoConfig.gpsConfig);
+    const canvas = map.getCanvas();
+    // A command frames clear of an overlay sat over the map, exactly as the plan's own camera does.
+    const padding = getVisibleRectFitPadding(options.padding ?? DEFAULT_FIT_PADDING, framingRect());
+    const camera = cameraForLocalRect(rect, geoConfig.gpsConfig, bearing, { width: canvas.clientWidth, height: canvas.clientHeight }, padding);
+    if (!camera) {
+        // No camera to compute against, but a caller that named a zoom floor still
+        // has a usable answer: centre the rect and honor the floor.
+        if (options.minZoom !== undefined) {
+            map.easeTo({
+                center: LngLatBounds.convert(bounds).getCenter(),
+                zoom: clampZoom(map, options.minZoom),
+                bearing,
+                duration: options.duration ?? 500,
+                essential: true,
+            });
+            return;
+        }
+        map.fitBounds(bounds, { padding, bearing, essential: true });
+        return;
+    }
+    // Scale duration with travel distance (screens + zoom) so far fits fly gradually.
+    // Clamp here, not via maplibre's `maxDuration`, which snaps an over-long flight to 0.
+    const fromPx = map.project(map.getCenter());
+    const toPx = map.project(camera.center);
+    const screenSpan = Math.max(map.getCanvas().clientWidth, map.getCanvas().clientHeight, 1);
+    const screensAway = Math.hypot(toPx.x - fromPx.x, toPx.y - fromPx.y) / screenSpan;
+    const targetZoom = clampZoom(map, Math.max(camera.zoom, options.minZoom ?? -Infinity));
+    const zoomDelta = Math.abs(map.getZoom() - targetZoom);
+    const duration = options.duration ?? Math.min(2800, 500 + screensAway * 450 + zoomDelta * 150);
+    // The fit's centre offsets the padding imbalance at the fit's own scale; at
+    // any other zoom that offset would land the rect off the padded area's centre.
+    const center = targetZoom === camera.zoom
+        ? camera.center
+        : (cameraForLocalRect(rect, geoConfig.gpsConfig, bearing, { width: canvas.clientWidth, height: canvas.clientHeight }, padding, targetZoom)?.center ?? camera.center);
+    const cameraOptions = {
+        center,
+        zoom: targetZoom,
+        bearing,
+        duration,
+        essential: true,
+    };
+    // Near moves: a plain ease, no zoom-out swoop needed.
+    if (screensAway <= 1.2 && zoomDelta <= 1.5) {
+        map.easeTo(cameraOptions);
+        return;
+    }
+    const fitBothBounds = map.getBounds().extend(LngLatBounds.convert(bounds));
+    const both = map.cameraForBounds(fitBothBounds, { padding, bearing });
+    // Already wide enough to show start and end together: a single ease is smoother.
+    if (!both?.center || typeof both.zoom !== 'number' || both.zoom >= map.getZoom() - 0.2) {
+        map.easeTo(cameraOptions);
+        return;
+    }
+    // Fly with the highest curve whose swoop stays above minZoom, flattened a notch
+    // to tame the arc.
+    const safeCurve = findSafeFlyToCurve(map, targetZoom, both.zoom);
+    if (safeCurve !== null) {
+        const curve = Math.max(MIN_SAFE_FLYTO_CURVE, safeCurve * REDUCED_FLYTO_CURVE_FACTOR);
+        const reducedDuration = Math.round(duration * REDUCED_FLYTO_DURATION_FACTOR);
+        map.flyTo({ ...cameraOptions, curve, duration: reducedDuration });
+        return;
+    }
+    // Any swoop would dip below minZoom (e.g. fitting from far out) — pan with a
+    // plain ease instead, so the camera never flings out over blank basemap.
+    map.easeTo(cameraOptions);
+}

package/dist/esm/components/Maplibre/utils/hit-test-registry.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Point hit test: `true` when the point is claimed by the owning layer. Each
+ * registry documents its own coordinate space (model or screen).
+ */
+export type PointHitTest = (x: number, y: number) => boolean;
+export interface HitTestRegistry {
+    /** Installed by the Maplibre hook that owns the layer; `null` while inactive. */
+    set(fn: PointHitTest | null): void;
+    test(x: number, y: number): boolean;
+}
+/**
+ * A slot the plan's click seam (`clickedPlan` in Map/pointer.ts) reads and a
+ * Maplibre hook writes. Deliberately a leaf module (no imports) so consulting a
+ * native MapLibre layer's hit test does not couple the click seam to the hook
+ * that owns that layer. Untested points fall through as "not claimed".
+ */
+export declare function createHitTestRegistry(): HitTestRegistry;
+//# sourceMappingURL=hit-test-registry.d.ts.map

package/dist/esm/components/Maplibre/utils/hit-test-registry.js

@@ -0,0 +1,17 @@
+/**
+ * A slot the plan's click seam (`clickedPlan` in Map/pointer.ts) reads and a
+ * Maplibre hook writes. Deliberately a leaf module (no imports) so consulting a
+ * native MapLibre layer's hit test does not couple the click seam to the hook
+ * that owns that layer. Untested points fall through as "not claimed".
+ */
+export function createHitTestRegistry() {
+    let hitTest = null;
+    return {
+        set(fn) {
+            hitTest = fn;
+        },
+        test(x, y) {
+            return hitTest ? hitTest(x, y) : false;
+        },
+    };
+}

package/dist/esm/components/Maplibre/utils/layer-defs.d.ts

@@ -0,0 +1,9 @@
+import { type LayerDef } from '@expofp/renderer';
+/**
+ * Indexes a layer tree by name, one list per name — floors repeat across scenes.
+ * @param layer - The root to walk.
+ * @param acc - The accumulator, threaded through recursion.
+ * @returns Layer defs by name.
+ */
+export declare function collectLayerDefsByName(layer: LayerDef, acc?: Map<string, LayerDef<import("@expofp/renderer").RenderableDef>[]>): Map<string, LayerDef<import("@expofp/renderer").RenderableDef>[]>;
+//# sourceMappingURL=layer-defs.d.ts.map

package/dist/esm/components/Maplibre/utils/layer-defs.js

@@ -0,0 +1,19 @@
+import { isLayerDef } from '@expofp/renderer';
+/**
+ * Indexes a layer tree by name, one list per name — floors repeat across scenes.
+ * @param layer - The root to walk.
+ * @param acc - The accumulator, threaded through recursion.
+ * @returns Layer defs by name.
+ */
+export function collectLayerDefsByName(layer, acc = new Map()) {
+    if (layer.name) {
+        const defs = acc.get(layer.name) ?? [];
+        defs.push(layer);
+        acc.set(layer.name, defs);
+    }
+    for (const child of layer.children ?? []) {
+        if (isLayerDef(child))
+            collectLayerDefsByName(child, acc);
+    }
+    return acc;
+}

package/dist/esm/components/Maplibre/utils/local-viewport.d.ts

@@ -0,0 +1,13 @@
+import { Box } from '@expofp/geometry';
+import type { Map as MaplibreMap } from 'maplibre-gl';
+import { type GpsConfig } from '../../../utils/gps';
+/**
+ * The current viewport as a local-space AABB: the four canvas corners
+ * unprojected to lng/lat, then through the plan's GPS anchor transform. With
+ * a rotated camera the true viewport is a rotated quad in local space; its
+ * AABB is a standard approximation that inflates all venues' overlap alike.
+ * Camera corners are trusted map output, so they intentionally bypass the
+ * distance guard used for external user-location data.
+ */
+export declare function getLocalViewport(map: MaplibreMap, gpsConfig: GpsConfig): Box | null;
+//# sourceMappingURL=local-viewport.d.ts.map

package/dist/esm/components/Maplibre/utils/local-viewport.js

@@ -0,0 +1,31 @@
+import { Box } from '@expofp/geometry';
+import { projectMapPointToLocal } from '../../../utils/gps';
+/**
+ * The current viewport as a local-space AABB: the four canvas corners
+ * unprojected to lng/lat, then through the plan's GPS anchor transform. With
+ * a rotated camera the true viewport is a rotated quad in local space; its
+ * AABB is a standard approximation that inflates all venues' overlap alike.
+ * Camera corners are trusted map output, so they intentionally bypass the
+ * distance guard used for external user-location data.
+ */
+export function getLocalViewport(map, gpsConfig) {
+    const canvas = map.getCanvas();
+    const width = canvas.clientWidth;
+    const height = canvas.clientHeight;
+    const corners = [];
+    for (const [x, y] of [
+        [0, 0],
+        [width, 0],
+        [width, height],
+        [0, height],
+    ]) {
+        const point = projectMapPointToLocal(map.unproject([x, y]), gpsConfig);
+        if (!point)
+            break;
+        corners.push(point);
+    }
+    if (corners.length === 4)
+        return Box.fromPoints(corners);
+    const center = projectMapPointToLocal(map.getCenter(), gpsConfig);
+    return center ? new Box(center.x, center.y) : null;
+}

package/dist/esm/components/Maplibre/utils/map-helpers.d.ts

@@ -0,0 +1,21 @@
+import { type Map as MaplibreMap } from 'maplibre-gl';
+import { type MapOptions, type TileSourceConfig } from '../MaplibreWrapper.js';
+export declare const LIGHT_TILE_SOURCE: TileSourceConfig;
+export declare const DARK_TILE_SOURCE: TileSourceConfig;
+export declare const MAP_MIN_ZOOM = 12;
+export declare function applyMapDimValue(map: MaplibreMap | null, value: number): void;
+/**
+ * Applies a camera policy to a live map.
+ *
+ * Only the pitch moves the camera. The zoom and pan limits are ceilings, not positions, so they are
+ * set outright; they touch the camera only when it already sits outside a new limit, and MapLibre
+ * then clamps it rather than easing it.
+ *
+ * A pitch change eases when `uiState.animatePitch` is set, over `uiState.mapSettings.pitchtime`,
+ * which is the same setting the floor plan view eases by.
+ * @param map - The map, or null before it exists.
+ * @param mapOptions - The policy; an omitted field restores MapLibre's own default.
+ */
+export declare function applyMapOptions(map: MaplibreMap | null, mapOptions: Partial<MapOptions>): void;
+export declare function getTileSource(): TileSourceConfig;
+//# sourceMappingURL=map-helpers.d.ts.map

package/dist/esm/components/Maplibre/utils/map-helpers.js

@@ -0,0 +1,85 @@
+import { getFpGeo } from '../../../data/fpGeo.js';
+import store, { uiState } from '../../../store/index.js';
+import settings from '../../../tools/settings.js';
+import { MAP_DIM_LAYER_ID } from '../MaplibreWrapper.js';
+import { DARK_MATTER_PAINT, POSITRON_PAINT, recolorStyle } from './basemap-palette.js';
+import { resolveMapTheme } from './map-theme.js';
+// OpenFreeMap: free, keyless, no usage limits. Its Positron/Dark pair shares one
+// tile schema, layer ids and glyph stack, so everything the SDK layers on top
+// (English label rewriting, palette overrides) works on both. The palettes are
+// keyed by these styles' layer ids: swapping in another style (the vendored
+// `styles/mapbox-streets*.ts`, say) means dropping or rewriting `restyle` too.
+export const LIGHT_TILE_SOURCE = {
+    style: 'https://tiles.openfreemap.org/styles/positron',
+    restyle: (style) => recolorStyle(style, POSITRON_PAINT),
+};
+export const DARK_TILE_SOURCE = {
+    style: 'https://tiles.openfreemap.org/styles/dark',
+    restyle: (style) => recolorStyle(style, DARK_MATTER_PAINT),
+};
+// Camera pan is unrestricted (no maxBounds). Zoom-out is still gated by minZoom; raised from the
+// former 14 to keep the venue from shrinking too far when zooming out.
+export const MAP_MIN_ZOOM = 12;
+export function applyMapDimValue(map, value) {
+    if (!map?.getLayer(MAP_DIM_LAYER_ID))
+        return;
+    map.setPaintProperty(MAP_DIM_LAYER_ID, 'fill-opacity', clampOpacity(value));
+    map.triggerRepaint();
+}
+function clampOpacity(value) {
+    return Math.min(Math.max(value, 0), 1);
+}
+/**
+ * Applies a camera policy to a live map.
+ *
+ * Only the pitch moves the camera. The zoom and pan limits are ceilings, not positions, so they are
+ * set outright; they touch the camera only when it already sits outside a new limit, and MapLibre
+ * then clamps it rather than easing it.
+ *
+ * A pitch change eases when `uiState.animatePitch` is set, over `uiState.mapSettings.pitchtime`,
+ * which is the same setting the floor plan view eases by.
+ * @param map - The map, or null before it exists.
+ * @param mapOptions - The policy; an omitted field restores MapLibre's own default.
+ */
+export function applyMapOptions(map, mapOptions) {
+    if (!map)
+        return;
+    map.setMinZoom(mapOptions.minZoom ?? null);
+    map.setMaxZoom(mapOptions.maxZoom ?? null);
+    map.setMaxBounds(mapOptions.maxBounds ?? null);
+    const { pitch, maxPitch } = mapOptions;
+    const animatePitch = uiState.animatePitch;
+    const currentPitch = map.getPitch();
+    // Closing the ceiling below where the camera already sits would snap it there. Let the move
+    // land first, then close the ceiling behind it.
+    const shouldDeferMaxPitch = Boolean(animatePitch && pitch != null && maxPitch != null && maxPitch < currentPitch);
+    // `null` tells MapLibre to go back to its own default, which is what an omitted field means.
+    if (!shouldDeferMaxPitch)
+        map.setMaxPitch(maxPitch ?? null);
+    if (pitch == null || currentPitch === pitch)
+        return;
+    if (animatePitch) {
+        map.easeTo({ pitch, duration: uiState.mapSettings.pitchtime });
+        if (shouldDeferMaxPitch) {
+            map.once('moveend', () => map.setMaxPitch(maxPitch));
+        }
+    }
+    else {
+        map.jumpTo({ pitch });
+    }
+}
+export function getTileSource() {
+    const maplibreOptions = store.fp?.maplibre ?? window.__efpMaplibre;
+    // A host-supplied style is a complete style document — it already carries its
+    // own palette, so the theme has nothing to pick between and stays out of it.
+    if (maplibreOptions?.style) {
+        return { style: maplibreOptions.style, offline: maplibreOptions.offline };
+    }
+    if (maplibreOptions?.styleUrl) {
+        return { style: maplibreOptions.styleUrl, offline: maplibreOptions.offline };
+    }
+    // The drawing decides the palette: what the Designer wrote into its geo
+    // config, else what its background color implies.
+    const theme = resolveMapTheme(getFpGeo()?.properties?.config?.style, settings.backgroundColor);
+    return theme === 'dark' ? DARK_TILE_SOURCE : LIGHT_TILE_SOURCE;
+}

package/dist/esm/components/Maplibre/utils/map-theme.d.ts

@@ -0,0 +1,20 @@
+import { type MapTheme } from '@expofp/schema';
+/**
+ * The palette implied by the drawing's background color — the fallback for
+ * drawings that predate `__fpGeo.properties.config.style`.
+ *
+ * `'none'` is a real authored value (the plan asks for no background at all)
+ * and is not a parseable color, so it and anything else unparseable resolve to
+ * the light palette the SDK has always used.
+ *
+ * Inferring a palette from a background color is a guess — the two are separate
+ * decisions, and a plan may legitimately want a dark surround without a dark
+ * basemap. The Designer's explicit geo config avoids that ambiguity.
+ */
+export declare function deriveMapThemeFromBackground(backgroundColor: string | undefined): MapTheme;
+/**
+ * Resolve the basemap palette: the one the drawing declares in its geo config,
+ * else the one its background color implies.
+ */
+export declare function resolveMapTheme(drawingTheme: MapTheme | undefined, backgroundColor: string | undefined): MapTheme;
+//# sourceMappingURL=map-theme.d.ts.map