@expofp/floorplan 0.0.0-experimental.2d6c681

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

@@ -0,0 +1,44 @@
+import Color from 'color';
+/**
+ * Below this HSL lightness (0–100) a background counts as dark.
+ *
+ * HSL lightness rather than WCAG relative luminance: the latter is heavily
+ * green-weighted, so a mid-grey `#808080` scores 0.216 and would read as dark
+ * against any sensible 0–1 threshold. On this scale it lands at 50.2 — just
+ * above the line, which is the intuitive answer for a mid-grey backdrop.
+ */
+const DARK_BACKGROUND_LIGHTNESS = 50;
+function isMapTheme(value) {
+    return value === 'light' || value === 'dark';
+}
+/**
+ * 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 function deriveMapThemeFromBackground(backgroundColor) {
+    if (!backgroundColor || backgroundColor === 'none')
+        return 'light';
+    try {
+        return Color(backgroundColor).lightness() < DARK_BACKGROUND_LIGHTNESS ? 'dark' : 'light';
+    }
+    catch {
+        return 'light';
+    }
+}
+/**
+ * Resolve the basemap palette: the one the drawing declares in its geo config,
+ * else the one its background color implies.
+ */
+export function resolveMapTheme(drawingTheme, backgroundColor) {
+    if (isMapTheme(drawingTheme))
+        return drawingTheme;
+    return deriveMapThemeFromBackground(backgroundColor);
+}

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

@@ -0,0 +1,22 @@
+import type { Map as MaplibreMap } from 'maplibre-gl';
+/**
+ * Stacking contract between the native marker stacks on the geo map, bottom
+ * to top: venue contours and name labels, then the outdoor POI markers, then
+ * the venue markers. MapLibre places symbols top-down, so the same order is
+ * the collision priority — venue markers claim their space first, POI markers
+ * next, and the venue labels steer around both instead of being covered.
+ *
+ * The stacks mount from separate hooks, and the POI one re-adds its layers
+ * whenever clustering toggles, so each inserts below the bottom layer of the
+ * stack above it rather than relying on mount order.
+ */
+/** The bottom layer of the outdoor POI marker stack (`usePoiMarkers`). */
+export declare const POI_MARKER_FLOOR_LAYER_ID = "expofp-poi-clusters";
+/** The bottom layer of the venue marker stack (`useVenueLayers`). */
+export declare const VENUE_MARKER_FLOOR_LAYER_ID = "expofp-venue-pin-circle";
+/**
+ * The `beforeId` that slots a layer under `floorLayerId`, or undefined (the
+ * top of the style) while that stack is not on the map.
+ */
+export declare const beforeLayer: (map: MaplibreMap, floorLayerId: string) => string | undefined;
+//# sourceMappingURL=marker-layer-order.d.ts.map

package/dist/esm/components/Maplibre/utils/marker-layer-order.js

@@ -0,0 +1,20 @@
+/**
+ * Stacking contract between the native marker stacks on the geo map, bottom
+ * to top: venue contours and name labels, then the outdoor POI markers, then
+ * the venue markers. MapLibre places symbols top-down, so the same order is
+ * the collision priority — venue markers claim their space first, POI markers
+ * next, and the venue labels steer around both instead of being covered.
+ *
+ * The stacks mount from separate hooks, and the POI one re-adds its layers
+ * whenever clustering toggles, so each inserts below the bottom layer of the
+ * stack above it rather than relying on mount order.
+ */
+/** The bottom layer of the outdoor POI marker stack (`usePoiMarkers`). */
+export const POI_MARKER_FLOOR_LAYER_ID = 'expofp-poi-clusters';
+/** The bottom layer of the venue marker stack (`useVenueLayers`). */
+export const VENUE_MARKER_FLOOR_LAYER_ID = 'expofp-venue-pin-circle';
+/**
+ * The `beforeId` that slots a layer under `floorLayerId`, or undefined (the
+ * top of the style) while that stack is not on the map.
+ */
+export const beforeLayer = (map, floorLayerId) => map.getLayer(floorLayerId) ? floorLayerId : undefined;

package/dist/esm/components/Maplibre/utils/pmtiles-range-fallback.d.ts

@@ -0,0 +1,53 @@
+import { type Protocol, type RangeResponse, type Source } from 'pmtiles';
+/**
+ * A PMTiles source that also works against hosts which accept a `Range` header
+ * and then answer `200` with something other than the requested slice.
+ *
+ * The Android SDK serves offline archives through `WebViewAssetLoader`, whose
+ * path handlers never see request headers: Chromium applies the range's start
+ * offset to the file stream and then streams to EOF, answering `200` with a
+ * `Content-Length` that merely echoes the request. PMTiles' own guard compares
+ * that header against the requested length and so lets it through — every tile
+ * read then silently receives the rest of the archive instead of one tile,
+ * which decodes into a mostly blank basemap and no error anywhere.
+ *
+ * So probe once, at offset 0, and decide from the status:
+ *
+ * - `206` — a well-behaved host. Everything is delegated to {@link FetchSource},
+ *   which keeps its 416 retry and ETag-mismatch handling intact.
+ * - `200` — the host ignored the range, which means the body it just returned
+ *   *is* the archive from byte 0. Keep it and slice locally.
+ *
+ * The body is held as a `Blob` rather than an `ArrayBuffer` so the browser can
+ * back it with a temp file instead of the JS heap — an offline basemap runs to
+ * tens of megabytes and the SDK still has to survive older Android WebViews.
+ */
+export declare class RangeTolerantSource implements Source {
+    private readonly url;
+    private readonly ranged;
+    /** Memoised probe: the whole archive, or `null` when ranges are honoured. */
+    private archive;
+    constructor(url: string);
+    getKey(): string;
+    getBytes(offset: number, length: number, signal?: AbortSignal, etag?: string): Promise<RangeResponse>;
+    /**
+     * Read the head of the archive and work out which kind of host this is.
+     *
+     * The probe deliberately ignores the caller's `AbortSignal`. It is memoised
+     * for the source's lifetime, so a first tile that gets cancelled mid-flight
+     * must not leave every later read awaiting a rejected promise.
+     */
+    private probe;
+}
+/**
+ * Point the protocol at {@link RangeTolerantSource} for one archive URL.
+ *
+ * Registering ahead of the first tile request is what makes this take effect:
+ * `Protocol` creates a plain {@link FetchSource} for any `pmtiles://` URL it
+ * has not already been given an instance for.
+ *
+ * Only string-URL styles are covered. An inline style object carries absolute
+ * URLs the SDK never resolves, so its PMTiles sources keep the stock source.
+ */
+export declare function registerPmtilesArchive(protocol: Protocol, url: string): void;
+//# sourceMappingURL=pmtiles-range-fallback.d.ts.map

package/dist/esm/components/Maplibre/utils/pmtiles-range-fallback.js

@@ -0,0 +1,110 @@
+import { FetchSource, PMTiles } from 'pmtiles';
+/**
+ * Bytes the probe asks for — PMTiles' own first read is this same 16 KiB
+ * header-plus-root-directory block, so the probe costs one extra request that
+ * the HTTP cache usually serves back to PMTiles a moment later.
+ */
+const PROBE_LENGTH = 16384;
+/**
+ * A PMTiles source that also works against hosts which accept a `Range` header
+ * and then answer `200` with something other than the requested slice.
+ *
+ * The Android SDK serves offline archives through `WebViewAssetLoader`, whose
+ * path handlers never see request headers: Chromium applies the range's start
+ * offset to the file stream and then streams to EOF, answering `200` with a
+ * `Content-Length` that merely echoes the request. PMTiles' own guard compares
+ * that header against the requested length and so lets it through — every tile
+ * read then silently receives the rest of the archive instead of one tile,
+ * which decodes into a mostly blank basemap and no error anywhere.
+ *
+ * So probe once, at offset 0, and decide from the status:
+ *
+ * - `206` — a well-behaved host. Everything is delegated to {@link FetchSource},
+ *   which keeps its 416 retry and ETag-mismatch handling intact.
+ * - `200` — the host ignored the range, which means the body it just returned
+ *   *is* the archive from byte 0. Keep it and slice locally.
+ *
+ * The body is held as a `Blob` rather than an `ArrayBuffer` so the browser can
+ * back it with a temp file instead of the JS heap — an offline basemap runs to
+ * tens of megabytes and the SDK still has to survive older Android WebViews.
+ */
+export class RangeTolerantSource {
+    constructor(url) {
+        this.url = url;
+        this.ranged = new FetchSource(url);
+    }
+    getKey() {
+        return this.url;
+    }
+    async getBytes(offset, length, signal, etag) {
+        if (!this.archive)
+            this.archive = this.probe();
+        const archive = await this.archive;
+        if (!archive)
+            return this.ranged.getBytes(offset, length, signal, etag);
+        throwIfAborted(signal);
+        return { data: await blobToArrayBuffer(archive.slice(offset, offset + length)) };
+    }
+    /**
+     * Read the head of the archive and work out which kind of host this is.
+     *
+     * The probe deliberately ignores the caller's `AbortSignal`. It is memoised
+     * for the source's lifetime, so a first tile that gets cancelled mid-flight
+     * must not leave every later read awaiting a rejected promise.
+     */
+    async probe() {
+        let response;
+        try {
+            response = await fetch(this.url, { headers: { Range: `bytes=0-${PROBE_LENGTH - 1}` } });
+        }
+        catch {
+            // Let FetchSource make the request again and report the failure in its
+            // own words, rather than inventing a second error vocabulary here.
+            return null;
+        }
+        if (response.status !== 200)
+            return null;
+        const body = await response.blob();
+        // Exactly the requested length means the host did honour the range and only
+        // got the status code wrong — FetchSource's own `200` path handles that, and
+        // buffering 16 KiB of a much larger archive would break every later read.
+        if (body.size === PROBE_LENGTH)
+            return null;
+        // Anything else is the whole archive: larger because the range was ignored,
+        // smaller because the archive really is that small.
+        return body;
+    }
+}
+/**
+ * Point the protocol at {@link RangeTolerantSource} for one archive URL.
+ *
+ * Registering ahead of the first tile request is what makes this take effect:
+ * `Protocol` creates a plain {@link FetchSource} for any `pmtiles://` URL it
+ * has not already been given an instance for.
+ *
+ * Only string-URL styles are covered. An inline style object carries absolute
+ * URLs the SDK never resolves, so its PMTiles sources keep the stock source.
+ */
+export function registerPmtilesArchive(protocol, url) {
+    if (protocol.get(url))
+        return;
+    protocol.add(new PMTiles(new RangeTolerantSource(url)));
+}
+function throwIfAborted(signal) {
+    if (!signal?.aborted)
+        return;
+    // `AbortSignal.throwIfAborted` and `.reason` are both newer than the WebViews
+    // the SDK targets, so raise the equivalent by hand.
+    throw signal.reason ?? new DOMException('The operation was aborted.', 'AbortError');
+}
+async function blobToArrayBuffer(blob) {
+    // `Blob.arrayBuffer()` is Chrome 76+; fall back for the older Android WebViews.
+    if (typeof blob.arrayBuffer === 'function')
+        return blob.arrayBuffer();
+    return new Promise((resolve, reject) => {
+        const reader = new FileReader();
+        reader.onload = () => resolve(reader.result);
+        reader.onerror = () => reject(reader.error);
+        reader.readAsArrayBuffer(blob);
+    });
+}

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

@@ -0,0 +1,8 @@
+/**
+ * Screen-space hit-test (viewport `clientX`/`clientY`) against the outdoor PoI
+ * symbol/cluster layers, set by `usePoiMarkers` while active. The plan's click
+ * seam (`clickedPlan` in Map/pointer.ts) consults it so a click handled by a
+ * native MapLibre layer does not also select the booth underneath.
+ */
+export declare const poiMarkerHitTest: import("./hit-test-registry.js").HitTestRegistry;
+//# sourceMappingURL=poi-marker-hit-test.d.ts.map

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

@@ -0,0 +1,8 @@
+import { createHitTestRegistry } from './hit-test-registry.js';
+/**
+ * Screen-space hit-test (viewport `clientX`/`clientY`) against the outdoor PoI
+ * symbol/cluster layers, set by `usePoiMarkers` while active. The plan's click
+ * seam (`clickedPlan` in Map/pointer.ts) consults it so a click handled by a
+ * native MapLibre layer does not also select the booth underneath.
+ */
+export const poiMarkerHitTest = createHitTestRegistry();

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

@@ -0,0 +1,19 @@
+import { type StyleSpecification, type TransformStyleFunction } from 'maplibre-gl';
+/**
+ * Build a MapLibre `transformStyle` hook that makes a style's internal URLs
+ * safe to use, or `undefined` when none is needed.
+ *
+ * MapLibre requires the URLs *inside* a style — `sprite`, `glyphs`, source
+ * `url`, and source `tiles` — to be fully absolute before it consumes them;
+ * for example, `normalizeSpriteURL` calls `new URL(url)` with no base and
+ * rejects rooted or relative values.
+ *
+ * Inline style objects have no style URL to resolve against; callers must pass
+ * already-absolute internals for those.
+ *
+ * `restyle`, when given, edits the style last — after URL resolution — for
+ * changes the style document cannot carry itself, such as a palette applied to
+ * a hosted style.
+ */
+export declare function createStyleTransform(style: string | StyleSpecification, onPmtilesArchive?: (url: string) => void, restyle?: (style: StyleSpecification) => StyleSpecification): TransformStyleFunction | undefined;
+//# sourceMappingURL=resolve-map-style.d.ts.map

package/dist/esm/components/Maplibre/utils/resolve-map-style.js

@@ -0,0 +1,73 @@
+/**
+ * Build a MapLibre `transformStyle` hook that makes a style's internal URLs
+ * safe to use, or `undefined` when none is needed.
+ *
+ * MapLibre requires the URLs *inside* a style — `sprite`, `glyphs`, source
+ * `url`, and source `tiles` — to be fully absolute before it consumes them;
+ * for example, `normalizeSpriteURL` calls `new URL(url)` with no base and
+ * rejects rooted or relative values.
+ *
+ * Inline style objects have no style URL to resolve against; callers must pass
+ * already-absolute internals for those.
+ *
+ * `restyle`, when given, edits the style last — after URL resolution — for
+ * changes the style document cannot carry itself, such as a palette applied to
+ * a hosted style.
+ */
+export function createStyleTransform(style, onPmtilesArchive, restyle) {
+    if (typeof style !== 'string') {
+        return restyle ? (_previous, next) => restyle(next) : undefined;
+    }
+    // Base-URL resolution only (a relative style path resolves against the page URL) —
+    // not a query read (plan §4.11).
+    const styleUrl = new URL(style, window.location.href).href;
+    // `new URL` percent-encodes `{`/`}`, which MapLibre glyph/tile templates
+    // (`{fontstack}`, `{range}`, `{z}/{x}/{y}`) rely on — restore them.
+    const absolutize = (url) => new URL(url, styleUrl).href.replace(/%7B/g, '{').replace(/%7D/g, '}');
+    const absolutizeStyleUrl = (url) => {
+        if (!url.startsWith('pmtiles://'))
+            return absolutize(url);
+        // This is the only point where the archive's serving URL is known: the
+        // style is MapLibre's to fetch, and `Protocol` binds a source to a URL the
+        // first time it sees one. `transformStyle` runs before MapLibre creates the
+        // sources, so a listener here is still early enough to choose that source.
+        const archive = absolutize(url.slice('pmtiles://'.length));
+        onPmtilesArchive?.(archive);
+        return `pmtiles://${archive}`;
+    };
+    return (_previous, next) => {
+        const resolved = { ...next };
+        if (typeof resolved.sprite === 'string')
+            resolved.sprite = absolutize(resolved.sprite);
+        else if (Array.isArray(resolved.sprite)) {
+            resolved.sprite = resolved.sprite.map((sprite) => {
+                if (!sprite || typeof sprite !== 'object')
+                    return sprite;
+                const withUrl = sprite;
+                if (typeof withUrl.url !== 'string')
+                    return sprite;
+                return { ...withUrl, url: absolutize(withUrl.url) };
+            });
+        }
+        if (typeof resolved.glyphs === 'string')
+            resolved.glyphs = absolutize(resolved.glyphs);
+        const sources = resolved.sources;
+        if (sources) {
+            resolved.sources = { ...sources };
+            for (const [id, source] of Object.entries(sources)) {
+                if (!source || typeof source !== 'object')
+                    continue;
+                const withUrls = source;
+                const nextSource = { ...withUrls };
+                if (typeof nextSource.url === 'string') {
+                    nextSource.url = absolutizeStyleUrl(nextSource.url);
+                }
+                if (Array.isArray(nextSource.tiles)) {
+                    nextSource.tiles = nextSource.tiles.map((tileUrl) => typeof tileUrl === 'string' ? absolutizeStyleUrl(tileUrl) : tileUrl);
+                }
+                resolved.sources[id] = nextSource;
+            }
+        }
+        return restyle ? restyle(resolved) : resolved;
+    };
+}

package/dist/esm/components/Maplibre/utils/solver.d.ts

@@ -0,0 +1,23 @@
+interface GeoAnchorPoint {
+    x: number;
+    y: number;
+    lat: number;
+    lng: number;
+}
+export interface TransformGeoConfig {
+    p0: GeoAnchorPoint;
+    p1?: GeoAnchorPoint;
+    p2: GeoAnchorPoint;
+}
+/**
+ * Affine matrix mapping plan (SVG) coordinates to Mercator, used as the
+ * `staticTransform` in the `SceneDef` so the renderer can position the floor
+ * plan inside a Maplibre `CustomLayerInterface`.
+ *
+ * Solved by Gaussian elimination from 3 anchors. The third anchor is synthesized
+ * perpendicular to the p0->p2 diagonal, so the result is a similarity transform
+ * (uniform scale + rotation, no shear).
+ */
+export declare function calculateTransformMatrix(geoConfig: TransformGeoConfig, units?: string | null): number[];
+export {};
+//# sourceMappingURL=solver.d.ts.map

package/dist/esm/components/Maplibre/utils/solver.js

@@ -0,0 +1,238 @@
+import { MercatorCoordinate } from 'maplibre-gl';
+const PIVOT_EPSILON = 1e-12;
+const FEET_PER_METER = 3.28084;
+const EARTH_RADIUS_METERS = 6371000;
+// Angle/side-ratio gap beyond which an explicit p1 is treated as inconsistent
+// with the p0->p2 diagonal.
+const P1_ANGLE_TOLERANCE_DEG = 1;
+const P1_RATIO_TOLERANCE = 0.02;
+/**
+ * Affine matrix mapping plan (SVG) coordinates to Mercator, used as the
+ * `staticTransform` in the `SceneDef` so the renderer can position the floor
+ * plan inside a Maplibre `CustomLayerInterface`.
+ *
+ * Solved by Gaussian elimination from 3 anchors. The third anchor is synthesized
+ * perpendicular to the p0->p2 diagonal, so the result is a similarity transform
+ * (uniform scale + rotation, no shear).
+ */
+export function calculateTransformMatrix(geoConfig, units) {
+    // Place the plan from the p0->p2 diagonal plus a synthesized perpendicular,
+    // forcing a similarity (no shear). An explicit p1 is ignored: an inconsistent
+    // one shears the plan. Fall back to it only when the diagonal is degenerate
+    // (p0 ~ p2) and the perpendicular can't be built.
+    let p1;
+    let p1Source;
+    try {
+        p1 = createPerpendicularAnchorPoint(geoConfig);
+        p1Source = 'perpendicular';
+    }
+    catch (error) {
+        if (!geoConfig.p1)
+            throw error;
+        p1 = geoConfig.p1;
+        p1Source = 'explicit-fallback';
+    }
+    // A dropped p1 that disagrees with the diagonal signals inconsistent anchor
+    // data; warn so it's visible.
+    const explicitP1Consistency = checkExplicitP1Consistency(geoConfig);
+    if (p1Source === 'perpendicular' && explicitP1Consistency?.inconsistent) {
+        console.warn('Maplibre geo: ignoring inconsistent anchor p1; placing venue from the p0->p2 diagonal.', {
+            angleErrorDeg: explicitP1Consistency.angleErrorDeg,
+            sideRatioError: explicitP1Consistency.ratioError,
+        });
+    }
+    const points = [geoConfig.p0, p1, geoConfig.p2];
+    const scalesZ = [];
+    // Convert lat/lng to Mercator coordinates
+    const svgCoords = [];
+    const mercatorCoords = [];
+    for (const point of points) {
+        assertFiniteAnchorPoint(point);
+        svgCoords.push([point.x, point.y]);
+        const mercator = MercatorCoordinate.fromLngLat([point.lng, point.lat], 0);
+        const scaleZ = mercator.meterInMercatorCoordinateUnits();
+        assertFiniteNumber(mercator.x);
+        assertFiniteNumber(mercator.y);
+        assertFiniteNumber(scaleZ);
+        scalesZ.push(scaleZ);
+        mercatorCoords.push([mercator.x, mercator.y]);
+    }
+    // Solve for affine transformation matrix: [a b tx; c d ty; 0 0 1]
+    // System of equations:
+    // mercator_x = a * svg_x + b * svg_y + tx
+    // mercator_y = c * svg_x + d * svg_y + ty
+    // Build matrix equation: A * params = B
+    // params = [a, b, tx, c, d, ty]
+    const A = [];
+    const B = [];
+    for (let i = 0; i < 3; i++) {
+        const [svgX, svgY] = svgCoords[i];
+        const [mercX, mercY] = mercatorCoords[i];
+        // Equation for mercator_x
+        A.push([svgX, svgY, 1, 0, 0, 0]);
+        B.push(mercX);
+        // Equation for mercator_y
+        A.push([0, 0, 0, svgX, svgY, 1]);
+        B.push(mercY);
+    }
+    // This is a determined 6x6 system: 3 anchor points * 2 coordinates.
+    const params = gaussianElimination(A, B);
+    const [a, b, tx, c, d, ty] = params;
+    const unitsScale = units?.toLowerCase?.().trim() === 'ft' ? 1 / FEET_PER_METER : 1;
+    // Z values in renderer geometry are plan units; Maplibre expects Mercator units per meter.
+    const scaleZ = (scalesZ.reduce((acc, val) => acc + val, 0) / scalesZ.length) * unitsScale;
+    // prettier-ignore
+    const matrix = [
+        a, c, 0, 0,
+        b, d, 0, 0,
+        0, 0, scaleZ, 0,
+        tx, ty, 0, 1,
+    ];
+    if (!matrix.every(Number.isFinite)) {
+        throw new Error('Cannot calculate Maplibre transform: geo anchor points produced a non-finite matrix.');
+    }
+    return matrix;
+}
+// Compares the p0/p1/p2 triangle in plan space against its real-world (ground)
+// shape, measuring how far an explicit p1 disagrees. Null when p1 is absent.
+function checkExplicitP1Consistency(geoConfig) {
+    const explicitP1 = geoConfig.p1;
+    if (!explicitP1)
+        return null;
+    const svg = describeTriangle(geoConfig.p0.x, geoConfig.p0.y, explicitP1.x, explicitP1.y, geoConfig.p2.x, geoConfig.p2.y);
+    const ground = describeGroundTriangle(geoConfig.p0, explicitP1, geoConfig.p2);
+    const angleErrorDeg = Math.abs(svg.angleDeg - ground.angleDeg);
+    const ratioError = Number.isFinite(ground.axisRatio) && ground.axisRatio > 0
+        ? Math.abs(svg.axisRatio / ground.axisRatio - 1)
+        : Infinity;
+    return {
+        angleErrorDeg,
+        ratioError,
+        inconsistent: angleErrorDeg > P1_ANGLE_TOLERANCE_DEG || ratioError > P1_RATIO_TOLERANCE,
+    };
+}
+// Side-length ratio |a->c| / |a->b| and the angle at `a`, in a flat 2D space.
+function describeTriangle(ax, ay, bx, by, cx, cy) {
+    const ab = Math.hypot(bx - ax, by - ay);
+    const ac = Math.hypot(cx - ax, cy - ay);
+    const dot = (bx - ax) * (cx - ax) + (by - ay) * (cy - ay);
+    const cos = ab > 0 && ac > 0 ? dot / (ab * ac) : NaN;
+    return {
+        axisRatio: ab > 0 ? ac / ab : Infinity,
+        angleDeg: toDeg(Math.acos(Math.max(-1, Math.min(1, cos)))),
+    };
+}
+// describeTriangle on the sphere: true ground distances and bearing gap at p0.
+function describeGroundTriangle(p0, p1, p2) {
+    const toP1 = distance(p0.lat, p0.lng, p1.lat, p1.lng);
+    const toP2 = distance(p0.lat, p0.lng, p2.lat, p2.lng);
+    const bearingP1 = bearing(p0.lat, p0.lng, p1.lat, p1.lng);
+    const bearingP2 = bearing(p0.lat, p0.lng, p2.lat, p2.lng);
+    let angleDeg = Math.abs(bearingP2 - bearingP1) % 360;
+    if (angleDeg > 180)
+        angleDeg = 360 - angleDeg;
+    return {
+        axisRatio: toP1 > 0 ? toP2 / toP1 : Infinity,
+        angleDeg,
+    };
+}
+// Third anchor perpendicular to the p0->p2 diagonal, equal length in both plan
+// and ground space, so the solved transform is a similarity (no shear).
+function createPerpendicularAnchorPoint(geoConfig) {
+    const dx = geoConfig.p2.x - geoConfig.p0.x;
+    const dy = geoConfig.p2.y - geoConfig.p0.y;
+    if (dx === 0 && dy === 0) {
+        throw new Error('Cannot calculate Maplibre transform: p0 and p2 have identical SVG coordinates.');
+    }
+    const x = geoConfig.p0.x - dy;
+    const y = geoConfig.p0.y + dx;
+    const gpsDistance = distance(geoConfig.p0.lat, geoConfig.p0.lng, geoConfig.p2.lat, geoConfig.p2.lng);
+    const gpsBearing = bearing(geoConfig.p0.lat, geoConfig.p0.lng, geoConfig.p2.lat, geoConfig.p2.lng);
+    const [lng, lat] = destinationPoint(geoConfig.p0.lat, geoConfig.p0.lng, gpsDistance, gpsBearing + 90);
+    return { x, y, lat, lng };
+}
+function assertFiniteAnchorPoint(point) {
+    assertFiniteNumber(point.x);
+    assertFiniteNumber(point.y);
+    assertFiniteNumber(point.lat);
+    assertFiniteNumber(point.lng);
+}
+function assertFiniteNumber(value) {
+    if (!Number.isFinite(value)) {
+        throw new Error('Cannot calculate Maplibre transform: geo anchor points contain invalid coordinates.');
+    }
+}
+function toRad(value) {
+    return (value * Math.PI) / 180;
+}
+function toDeg(value) {
+    return (value * 180) / Math.PI;
+}
+// Great-circle distance between two GPS points, matching the legacy GPS conversion model.
+function distance(lat1, lng1, lat2, lng2) {
+    const phi1 = toRad(lat1);
+    const phi2 = toRad(lat2);
+    const deltaPhi = toRad(lat2 - lat1);
+    const deltaLambda = toRad(lng2 - lng1);
+    const a = Math.sin(deltaPhi / 2) * Math.sin(deltaPhi / 2) +
+        Math.cos(phi1) * Math.cos(phi2) * Math.sin(deltaLambda / 2) * Math.sin(deltaLambda / 2);
+    const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
+    return EARTH_RADIUS_METERS * c;
+}
+// Initial bearing from the first GPS point to the second, in degrees.
+function bearing(lat1, lng1, lat2, lng2) {
+    const phi1 = toRad(lat1);
+    const phi2 = toRad(lat2);
+    const deltaLambda = toRad(lng2 - lng1);
+    const y = Math.sin(deltaLambda) * Math.cos(phi2);
+    const x = Math.cos(phi1) * Math.sin(phi2) - Math.sin(phi1) * Math.cos(phi2) * Math.cos(deltaLambda);
+    return (toDeg(Math.atan2(y, x)) + 360) % 360;
+}
+// Projects a GPS point by distance and bearing on a spherical earth model.
+function destinationPoint(lat, lng, distanceMeters, bearingDegrees) {
+    const delta = distanceMeters / EARTH_RADIUS_METERS;
+    const theta = toRad(bearingDegrees);
+    const phi1 = toRad(lat);
+    const lambda1 = toRad(lng);
+    const phi2 = Math.asin(Math.sin(phi1) * Math.cos(delta) + Math.cos(phi1) * Math.sin(delta) * Math.cos(theta));
+    const lambda2 = lambda1 +
+        Math.atan2(Math.sin(theta) * Math.sin(delta) * Math.cos(phi1), Math.cos(delta) - Math.sin(phi1) * Math.sin(phi2));
+    return [toDeg(lambda2), toDeg(phi2)];
+}
+// Gaussian elimination solver with partial pivoting
+function gaussianElimination(A, b) {
+    const n = A.length;
+    const augmented = A.map((row, i) => [...row, b[i]]);
+    // Forward elimination
+    for (let i = 0; i < n; i++) {
+        // Find pivot
+        let maxRow = i;
+        for (let k = i + 1; k < n; k++) {
+            if (Math.abs(augmented[k][i]) > Math.abs(augmented[maxRow][i])) {
+                maxRow = k;
+            }
+        }
+        // Swap rows
+        [augmented[i], augmented[maxRow]] = [augmented[maxRow], augmented[i]];
+        if (Math.abs(augmented[i][i]) < PIVOT_EPSILON) {
+            throw new Error('Cannot calculate Maplibre transform: geo anchor points are collinear or invalid.');
+        }
+        // Make all rows below this one 0 in current column
+        for (let k = i + 1; k < n; k++) {
+            const factor = augmented[k][i] / augmented[i][i];
+            for (let j = i; j <= n; j++) {
+                augmented[k][j] -= factor * augmented[i][j];
+            }
+        }
+    }
+    // Back substitution
+    const x = new Array(n);
+    for (let i = n - 1; i >= 0; i--) {
+        x[i] = augmented[i][n];
+        for (let j = i + 1; j < n; j++) {
+            x[i] -= augmented[i][j] * x[j];
+        }
+        x[i] /= augmented[i][i];
+    }
+    return x;
+}

package/dist/esm/components/Maplibre/utils/style-fonts.d.ts

@@ -0,0 +1,10 @@
+import type { Map as MaplibreMap } from 'maplibre-gl';
+/**
+ * Picks a text font stack that the style's glyph ranges can actually serve:
+ * reuses the font of an existing symbol layer rather than guessing a name.
+ * Prefers an upright face — some styles (e.g. Positron) lead with italics.
+ * The 'Noto Sans Regular' fallback matches the offline basemap's bundled
+ * fontstack, so offline copies render labels too.
+ */
+export declare function pickUprightTextFont(map: MaplibreMap): string[];
+//# sourceMappingURL=style-fonts.d.ts.map

package/dist/esm/components/Maplibre/utils/style-fonts.js

@@ -0,0 +1,24 @@
+/**
+ * Picks a text font stack that the style's glyph ranges can actually serve:
+ * reuses the font of an existing symbol layer rather than guessing a name.
+ * Prefers an upright face — some styles (e.g. Positron) lead with italics.
+ * The 'Noto Sans Regular' fallback matches the offline basemap's bundled
+ * fontstack, so offline copies render labels too.
+ */
+export function pickUprightTextFont(map) {
+    let fallback = null;
+    for (const layer of map.getStyle()?.layers ?? []) {
+        if (layer.type !== 'symbol')
+            continue;
+        const font = layer.layout?.['text-font'];
+        if (!Array.isArray(font) || !font.every((name) => typeof name === 'string'))
+            continue;
+        if (!font.some((name) => /italic/i.test(name)))
+            return font;
+        // `??=` (ES2021) is not downlevelled by the es2022 `tsc` build, and the SDK
+        // ships to chrome66-class WebViews — keep the assignment explicit.
+        if (fallback === null)
+            fallback = font;
+    }
+    return fallback ?? ['Noto Sans Regular'];
+}