@expofp/floorplan 0.0.0-experimental.cf063fc

package/dist/esm/components/Maplibre/utils/venue-calibration-console.d.ts

@@ -0,0 +1,10 @@
+import type { Map as MaplibreMap } from 'maplibre-gl';
+import type { GeoConfig } from './geo-config';
+/** A venue's `detailMinSizePx` entry, aimed at the current camera. */
+export interface VenueDetailPatch {
+    id: string;
+    detailMinSizePx: number;
+}
+/** Installs `window.__efpVenues()`; returns the uninstaller. */
+export declare function installVenueCalibrationConsole(map: MaplibreMap, geoConfig: GeoConfig): () => void;
+//# sourceMappingURL=venue-calibration-console.d.ts.map

package/dist/esm/components/Maplibre/utils/venue-calibration-console.js

@@ -0,0 +1,130 @@
+import data from '../../../data';
+import { extractVenueContourFromLayer } from '../../../data/svg';
+import { detailMinSizeFloor } from '../../../data/venues';
+import store from '../../../store';
+import { buildVenueCalibrationReport, describeFootprintSource, } from './venue-calibration.js';
+import { getViewportFitSizePx } from './venue-viewport-detail';
+/**
+ * Dev-only console handle for authoring the size axis: point the camera where a
+ * band should change, call it, and read the numbers to write into
+ * `data.venues`. This is the SDK-side half of contract §12 Guard 5 — the
+ * Designer preview owes the same readout in its own UI.
+ *
+ * `__efpVenues('in')` / `__efpVenues('out')` aim the detail edge at the
+ * zoom-in / zoom-out crossing instead of the plan-open one (the edge is
+ * sticky ±10%), and the printed `data.venues` patch moves every venue's
+ * detail ⇄ contour switch onto the current camera at once.
+ *
+ * Installed beside `__efpMaplibreMap` (MaplibreWrapper) and stripped from
+ * production builds.
+ */
+const GLOBAL = '__efpVenues';
+const px = (value) => typeof value === 'number' ? Math.round(value) : null;
+const atZoom = (value) => typeof value === 'number' ? Number(value.toFixed(2)) : null;
+const CROSSINGS = ['open', 'in', 'out'];
+const CROSSING_LABEL = {
+    open: 'when the plan opens here',
+    in: 'while zooming in',
+    out: 'while zooming out',
+};
+/**
+ * Authored `contour` is the one footprint source that leaves no trace on the
+ * parsed venue — the field and the resolved polygon share a name. Read it back
+ * off the raw payload, matched by `id` rather than array position so a dropped
+ * venue cannot shift the mapping (§9: lookup is id-only).
+ */
+function hasAuthoredContour(id) {
+    const raw = Array.isArray(data.venues) ? data.venues : [];
+    const entry = raw.find((venue) => typeof venue?.id === 'string' && venue.id.toLowerCase() === id.toLowerCase());
+    return Array.isArray(entry?.contour) && entry.contour.length >= 3;
+}
+/** One `console.table` row per venue, in venue-switch order. */
+function printReport(report) {
+    const rows = {};
+    for (const venue of report.venues) {
+        rows[venue.id] = {
+            band: venue.band,
+            'size px': px(venue.sizePx),
+            detailMinSizePx: venue.detail?.current ?? null,
+            'on this screen': venue.detail?.effective ?? null,
+            'screen cap': venue.detail?.viewportCapPx ?? null,
+            'detail → set': venue.detail?.setTo ?? null,
+            'marker edge': venue.marker.edge?.current ?? null,
+            'marker edge → set': venue.marker.edge?.setTo ?? null,
+            'scene minSizePx': venue.marker.sceneMinSizePx?.current ?? null,
+            'scene min → set': venue.marker.sceneMinSizePx?.setTo ?? null,
+            'marker maxSizePx': venue.marker.markerMaxSizePx?.current ?? null,
+            'marker max → set': venue.marker.markerMaxSizePx?.setTo ?? null,
+            footprint: venue.footprintSource,
+        };
+    }
+    console.log(`%c${GLOBAL}('${report.crossing}')%c zoom ${atZoom(report.zoom)} — "→ set" moves that ` +
+        `edge to the current camera (sticky edges: ${CROSSING_LABEL[report.crossing]})`, 'font-weight:600', 'font-weight:400');
+    console.table(rows);
+    for (const venue of report.venues) {
+        console.log(`${venue.name}: detail edge at zoom ${atZoom(venue.detail?.effectiveEdgeZoom) ?? '?'}, ` +
+            `marker/scene handoff at zoom ${atZoom(venue.marker.proceduralEdgeZoom) ?? '?'} ` +
+            `(${venue.marker.proceduralAtPx}px), footprint from ${venue.footprintSource}`);
+        for (const warning of [
+            venue.detail?.warning && `detailMinSizePx — ${venue.detail.warning}`,
+            venue.marker.edge?.warning && `markerMaxSizePx — ${venue.marker.edge.warning}`,
+            venue.marker.sceneMinSizePx?.warning &&
+                `${venue.marker.sceneMinSizePx.layer} minSizePx — ${venue.marker.sceneMinSizePx.warning}`,
+            venue.marker.markerMaxSizePx?.warning &&
+                `${venue.marker.markerMaxSizePx.layer} maxSizePx — ${venue.marker.markerMaxSizePx.warning}`,
+        ]) {
+            if (warning)
+                console.warn(`  ${venue.id}: ${warning}`);
+        }
+    }
+}
+/**
+ * The `data.venues` entries that put every venue's detail ⇄ contour switch on
+ * this camera, clamped the way the parser would clamp them. Venues the camera
+ * cannot place (a screen cap, the floor) are named so the author knows the
+ * patch alone will not line them up.
+ */
+function printPatch(report) {
+    const patch = [];
+    const offEdge = [];
+    for (const venue of report.venues) {
+        if (!venue.detail) {
+            offEdge.push(`${venue.id} (no footprint)`);
+            continue;
+        }
+        if (venue.detail.warning)
+            offEdge.push(venue.id);
+        patch.push({
+            id: venue.id,
+            detailMinSizePx: Math.max(detailMinSizeFloor(venue.marker.proceduralAtPx), venue.detail.setTo),
+        });
+    }
+    console.log(`data.venues patch — merge by id; switches detail ⇄ contour for every venue at zoom ` +
+        `${atZoom(report.zoom)} ${CROSSING_LABEL[report.crossing]}:\n` +
+        JSON.stringify(patch, null, 2));
+    if (offEdge.length) {
+        console.warn(`won't switch at this camera as written (see warnings): ${offEdge.join(', ')}`);
+    }
+    return patch;
+}
+/** Installs `window.__efpVenues()`; returns the uninstaller. */
+export function installVenueCalibrationConsole(map, geoConfig) {
+    const readout = (crossing = 'open') => {
+        if (!CROSSINGS.includes(crossing)) {
+            throw new Error(`${GLOBAL}(crossing): expected one of ${CROSSINGS.join(', ')}`);
+        }
+        const report = buildVenueCalibrationReport(store.venueStore.orderedVenues, geoConfig.gpsConfig, map.getZoom(), {
+            crossing,
+            footprintSource: (venue) => describeFootprintSource(venue, hasAuthoredContour(venue.id), extractVenueContourFromLayer),
+            fitSizePx: (venue) => getViewportFitSizePx(map, geoConfig, venue),
+        });
+        printReport(report);
+        return { ...report, patch: printPatch(report) };
+    };
+    const globals = window;
+    globals[GLOBAL] = readout;
+    return () => {
+        if (globals[GLOBAL] === readout)
+            delete globals[GLOBAL];
+    };
+}

package/dist/esm/components/Maplibre/utils/venue-calibration.d.ts

@@ -0,0 +1,127 @@
+import type { Box } from '@expofp/geometry';
+import { type ParsedVenueAuxLayer } from '../../../data/venues.js';
+import type { GpsConfig } from '../../../utils/gps.js';
+import type { VenueContourExtraction } from './venue-contour.js';
+import type { VenuePresentationState } from './venue-zoom.js';
+/**
+ * Answers the one question the size axis cannot be authored without: *standing
+ * here, what number do I write?*
+ *
+ * Contract §12 Guard 5 says every pixel field — `detailMinSizePx` (§4) and an
+ * aux layer's `minSizePx` / `maxSizePx` (§7) — is a calibration value that
+ * cannot be computed at a desk, because it depends on the venue footprint, the
+ * projection, the viewport and the device pixel ratio. The prescribed workflow
+ * is to point the camera where a band should change and read the number off the
+ * running plan. This module turns a camera position into exactly those numbers.
+ *
+ * Everything here is derived, never applied: it reports what to author, and the
+ * author writes it into `data.venues`.
+ */
+/** The structural slice of a venue this module reads — `Venue` satisfies it. */
+export interface CalibratableVenue {
+    readonly id: string;
+    readonly name: string;
+    readonly bounds: Box;
+    readonly detailMinSizePx?: number;
+    readonly markerMaxSizePx?: number;
+    readonly auxLayers: readonly ParsedVenueAuxLayer[];
+    readonly presentationState: VenuePresentationState | null;
+}
+export type VenueSizeBand = 'marker' | 'scene' | 'detail';
+/** One authorable pixel field, as it stands and as it would have to be written. */
+export interface CalibratedValue {
+    /** In force right now: the authored value, or the contract default. */
+    readonly current: number;
+    /** Write this to move the edge to the current camera. */
+    readonly setTo: number;
+    /** Zoom the value in force takes effect at, for this venue's footprint. */
+    readonly currentEdgeZoom: number | null;
+    /** Present when `setTo` would be clamped or rejected (§4, §11). */
+    readonly warning?: string;
+}
+export interface CalibratedAuxValue extends CalibratedValue {
+    readonly layer: string;
+}
+/**
+ * Which crossing a sticky edge — `detailMinSizePx` or `markerMaxSizePx` —
+ * should land on the current camera. Both are sticky (±10%), so one authored
+ * value flips at three sizes:
+ * exactly at the threshold when the plan opens (no incumbent side), at +10%
+ * while zooming in, at −10% while zooming out. Aux bounds are hard edges and
+ * ignore this.
+ */
+export type DetailCrossing = 'open' | 'in' | 'out';
+export interface CalibratedDetailValue extends CalibratedValue {
+    /**
+     * The cutoff actually deciding on this screen: `current`, lowered to where
+     * the venue's floors fit the viewport (`getViewportDetailThreshold`).
+     */
+    readonly effective: number;
+    readonly effectiveEdgeZoom: number | null;
+    /**
+     * This screen's ceiling on the cutoff — an authored value above it is never
+     * reached here, because the floors fit (and detail shows) first. Null when
+     * the fit size is unknown.
+     */
+    readonly viewportCapPx: number | null;
+}
+export interface VenueCalibration {
+    readonly id: string;
+    readonly name: string;
+    readonly band: VenueSizeBand;
+    /** The venue's size on screen at the reported camera, in CSS pixels (§4). */
+    readonly sizePx: number | null;
+    /** Guard 5 (2): which of §6's three sources the footprint came from. */
+    readonly footprintSource: string;
+    readonly footprintMinSizeMeters: number | null;
+    /** `venue.detailMinSizePx` — the scene ⇄ detail edge (§4). */
+    readonly detail: CalibratedDetailValue | null;
+    /**
+     * The scene ⇄ marker edge: the venue's own `markerMaxSizePx` (§4, Revision
+     * 5), plus where any authored artwork stops and starts around it.
+     */
+    readonly marker: {
+        /** `venue.markerMaxSizePx` — the marker ⇄ scene edge itself. */
+        readonly edge: CalibratedValue | null;
+        /** The edge in force: the authored `markerMaxSizePx`, or the default 60. */
+        readonly proceduralAtPx: number;
+        readonly proceduralEdgeZoom: number | null;
+        /** `minSizePx` on the venue's replacing scene layer, when it has one. */
+        readonly sceneMinSizePx: CalibratedAuxValue | null;
+        /** `maxSizePx` on the venue's marker layer, when it has one. */
+        readonly markerMaxSizePx: CalibratedAuxValue | null;
+    };
+}
+export interface VenueCalibrationReport {
+    readonly zoom: number;
+    readonly crossing: DetailCrossing;
+    readonly venues: readonly VenueCalibration[];
+}
+export interface VenueCalibrationOptions<V extends CalibratableVenue = CalibratableVenue> {
+    readonly footprintSource?: (venue: V) => string;
+    /**
+     * The venue's size where its floors fit the current viewport
+     * (`getViewportFitSizePx`). Omitted, the screen cap is not reported.
+     */
+    readonly fitSizePx?: (venue: V) => number | null;
+    readonly crossing?: DetailCrossing;
+}
+/**
+ * Which of §6's sources the footprint resolved from, in the parser's own order:
+ * an authored `contour` wins, then the first replacing scene layer that yields
+ * a usable ring, then the level-rect hull.
+ *
+ * Re-resolved rather than read back off the diagnostics: those are keyed by
+ * `venues[i]` paths into the raw payload, and Revision 4 frees their prose to
+ * be reworded, so parsing them would be the fragile route.
+ */
+export declare function describeFootprintSource(venue: CalibratableVenue, authoredContour: boolean, extract: (layer: string) => VenueContourExtraction): string;
+/**
+ * Builds the calibration readout for one camera position.
+ *
+ * `sizePx` is resolved exactly as `useVenueCameraTracking` resolves it, so the
+ * numbers reported are the ones the running plan is deciding on — not a
+ * parallel estimate that could disagree.
+ */
+export declare function buildVenueCalibrationReport<V extends CalibratableVenue>(venues: readonly V[], gpsConfig: GpsConfig | null | undefined, zoom: number, { footprintSource, fitSizePx, crossing, }?: VenueCalibrationOptions<V>): VenueCalibrationReport;
+//# sourceMappingURL=venue-calibration.d.ts.map

package/dist/esm/components/Maplibre/utils/venue-calibration.js

@@ -0,0 +1,144 @@
+import { DEFAULT_DETAIL_MIN_SIZE_PX, detailEdgeClearsMarkerEdge, detailMinSizeFloor, } from '../../../data/venues.js';
+import { resolveMarkerThreshold, resolveViewportDetailThreshold, SIZE_HYSTERESIS_RATIO, } from './venue-legibility.js';
+import { getFootprintSizePx, getVenueGroundFootprint, getZoomForFootprintSizePx, } from './venue-projection.js';
+/** The authored threshold whose `crossing` edge sits at `sizePx`. */
+function thresholdCrossingAt(sizePx, crossing) {
+    switch (crossing) {
+        case 'in':
+            return sizePx / (1 + SIZE_HYSTERESIS_RATIO);
+        case 'out':
+            return sizePx / (1 - SIZE_HYSTERESIS_RATIO);
+        case 'open':
+            return sizePx;
+    }
+}
+/**
+ * Which of §6's sources the footprint resolved from, in the parser's own order:
+ * an authored `contour` wins, then the first replacing scene layer that yields
+ * a usable ring, then the level-rect hull.
+ *
+ * Re-resolved rather than read back off the diagnostics: those are keyed by
+ * `venues[i]` paths into the raw payload, and Revision 4 frees their prose to
+ * be reworded, so parsing them would be the fragile route.
+ */
+export function describeFootprintSource(venue, authoredContour, extract) {
+    if (authoredContour)
+        return 'authored contour';
+    const replacingScenes = venue.auxLayers.filter((aux) => aux.render === 'scene' && aux.replacesDefault);
+    for (const aux of replacingScenes) {
+        let extraction;
+        try {
+            extraction = extract(aux.layer);
+        }
+        catch {
+            continue;
+        }
+        if (!extraction.ring)
+            continue;
+        return extraction.boundsFallback
+            ? `scene "${aux.layer}" (bounding box)`
+            : `scene "${aux.layer}" (outline)`;
+    }
+    return 'level-rect hull';
+}
+function bandOf(state) {
+    if (!state)
+        return 'marker';
+    if (state.detailVisible)
+        return 'detail';
+    return state.stickyEdges.markerScene === 'above' ? 'scene' : 'marker';
+}
+const roundPx = (sizePx) => Math.max(0, Math.round(sizePx));
+/**
+ * Builds the calibration readout for one camera position.
+ *
+ * `sizePx` is resolved exactly as `useVenueCameraTracking` resolves it, so the
+ * numbers reported are the ones the running plan is deciding on — not a
+ * parallel estimate that could disagree.
+ */
+export function buildVenueCalibrationReport(venues, gpsConfig, zoom, { footprintSource = () => 'unresolved', fitSizePx = () => null, crossing = 'open', } = {}) {
+    const venueRows = venues.map((venue) => {
+        const footprint = getVenueGroundFootprint(venue.bounds, gpsConfig);
+        const sizePx = getFootprintSizePx(footprint, zoom);
+        const detailInForce = venue.detailMinSizePx ?? DEFAULT_DETAIL_MIN_SIZE_PX;
+        const markerInForce = resolveMarkerThreshold(venue.markerMaxSizePx);
+        const detailFloor = detailMinSizeFloor(markerInForce);
+        const crossingSizePx = sizePx === null ? null : thresholdCrossingAt(sizePx, crossing);
+        const calibrate = (current, warn, atSizePx = sizePx) => {
+            if (atSizePx === null)
+                return null;
+            const setTo = roundPx(atSizePx);
+            return {
+                current,
+                setTo,
+                currentEdgeZoom: getZoomForFootprintSizePx(footprint, current),
+                warning: warn?.(setTo),
+            };
+        };
+        const calibrateDetail = () => {
+            const fit = fitSizePx(venue);
+            const cap = fit === null ? Infinity : resolveViewportDetailThreshold(Infinity, fit, detailFloor);
+            const viewportCapPx = Number.isFinite(cap) ? roundPx(cap) : null;
+            const value = calibrate(detailInForce, (setTo) => {
+                if (setTo < detailFloor) {
+                    return (`below the ${detailFloor} floor — the parser will clamp it (§4). ` +
+                        'Zoom in further, or accept the clamp.');
+                }
+                if (viewportCapPx !== null && setTo > viewportCapPx) {
+                    return (`above this screen's ${viewportCapPx}px cap — the floors fit the viewport ` +
+                        'sooner, so detail shows there instead. Pick a camera further out, or calibrate ' +
+                        'on a larger viewport (the cap scales with screen size).');
+                }
+                return undefined;
+            }, crossingSizePx);
+            if (!value)
+                return null;
+            const effective = resolveViewportDetailThreshold(detailInForce, fit, detailFloor);
+            return {
+                ...value,
+                effective: roundPx(effective),
+                effectiveEdgeZoom: getZoomForFootprintSizePx(footprint, effective),
+                viewportCapPx,
+            };
+        };
+        const scene = venue.auxLayers.find((aux) => aux.render === 'scene' && aux.replacesDefault);
+        const marker = venue.auxLayers.find((aux) => aux.render === 'marker');
+        return {
+            id: venue.id,
+            name: venue.name,
+            band: bandOf(venue.presentationState),
+            sizePx,
+            footprintSource: footprintSource(venue),
+            footprintMinSizeMeters: footprint?.minSizeMeters ?? null,
+            detail: calibrateDetail(),
+            marker: {
+                edge: calibrate(markerInForce, (setTo) => {
+                    if (setTo >= detailInForce) {
+                        return (`at or above this venue's detailMinSizePx (${detailInForce}), so §11 reports ` +
+                            'marker-max-size-inverted and uses 60. Raise detailMinSizePx first.');
+                    }
+                    if (!detailEdgeClearsMarkerEdge(detailInForce, setTo)) {
+                        return (`leaves no hysteresis band below this venue's detailMinSizePx (${detailInForce}), ` +
+                            `so the parser clamps detail up to ${detailMinSizeFloor(setTo)} (§4).`);
+                    }
+                    return undefined;
+                }, crossingSizePx),
+                proceduralAtPx: markerInForce,
+                proceduralEdgeZoom: getZoomForFootprintSizePx(footprint, markerInForce),
+                sceneMinSizePx: scene
+                    ? withLayer(scene.layer, calibrate(scene.minSizePx ?? markerInForce, (setTo) => setTo >= detailInForce
+                        ? `at or above this venue's detailMinSizePx (${detailInForce}), so §11 drops ` +
+                            'the entry as aux-range-never-visible. Raise detailMinSizePx first.'
+                        : undefined))
+                    : null,
+                markerMaxSizePx: marker
+                    ? withLayer(marker.layer, calibrate(typeof marker.maxSizePx === 'number' ? marker.maxSizePx : markerInForce))
+                    : null,
+            },
+        };
+    });
+    return { zoom, crossing, venues: venueRows };
+}
+function withLayer(layer, value) {
+    return value ? { layer, ...value } : null;
+}

package/dist/esm/components/Maplibre/utils/venue-camera-target.d.ts

@@ -0,0 +1,15 @@
+interface VenueEntryZoomInput {
+    currentZoom: number;
+    fitZoom: number;
+    maxZoom: number;
+    sizePx: number | null;
+    detailMinSizePx?: number;
+}
+export interface VenueEntryZoomResult {
+    zoom: number;
+    clampedBeforeDetail: boolean;
+}
+/** Minimum destination zoom that both fits the target and enters sticky indoor detail. */
+export declare function resolveVenueEntryZoom({ currentZoom, fitZoom, maxZoom, sizePx, detailMinSizePx, }: VenueEntryZoomInput): VenueEntryZoomResult;
+export {};
+//# sourceMappingURL=venue-camera-target.d.ts.map

package/dist/esm/components/Maplibre/utils/venue-camera-target.js

@@ -0,0 +1,19 @@
+import { resolveDetailThreshold, stickyEnterSizePx } from './venue-legibility.js';
+// How far past the sticky enter edge an entry aims. Landing exactly on the edge
+// leaves the measured size a floating-point ulp short about 1% of the time
+// (263.99999999999994 px against a 264 px edge) and the venue stays in its
+// contour; 0.01 zoom (0.7% of size) is invisible but clears that rounding.
+const DETAIL_ENTRY_ZOOM_MARGIN = 0.01;
+/** Minimum destination zoom that both fits the target and enters sticky indoor detail. */
+export function resolveVenueEntryZoom({ currentZoom, fitZoom, maxZoom, sizePx, detailMinSizePx, }) {
+    if (sizePx === null || !Number.isFinite(sizePx) || sizePx <= 0 || !Number.isFinite(currentZoom)) {
+        return { zoom: maxZoom, clampedBeforeDetail: true };
+    }
+    const entrySizePx = stickyEnterSizePx(resolveDetailThreshold(detailMinSizePx));
+    const criterionZoom = currentZoom + Math.log2(entrySizePx / sizePx) + DETAIL_ENTRY_ZOOM_MARGIN;
+    const targetZoom = Math.max(fitZoom, criterionZoom);
+    return {
+        zoom: Math.min(targetZoom, maxZoom),
+        clampedBeforeDetail: criterionZoom > maxZoom,
+    };
+}

package/dist/esm/components/Maplibre/utils/venue-contour.d.ts

@@ -0,0 +1,50 @@
+import { type Point2Like } from '@expofp/geometry';
+export interface FpPathMesh {
+    positions: number[][];
+    cells: number[][];
+}
+/** A ring derived from a scene layer's artwork. */
+export interface VenueContourRing {
+    ring: Point2Like[];
+    /**
+     * True when the ring is the artwork's bounding box rather than its outline —
+     * the case the contract tells authors to avoid (multiple paths, or a path
+     * carrying a filter/mask/clip-path/marker whose painted extent can exceed
+     * its geometry). A plain stroke does not trigger it; see
+     * {@link hasPaintExtendingEffect}.
+     */
+    boundsFallback: boolean;
+}
+/**
+ * A scene layer that supplied no ring, and why — "nothing" cannot explain
+ * itself to an author. Facts only: `parseVenues` is the sole emitter of venue
+ * diagnostics (§11), and this stays a pure geometry function.
+ */
+export interface VenueContourUnusable {
+    ring: null;
+    /**
+     * Distinct tag names, in document order, of the shape elements the layer
+     * drew in place of a path — the §6 kinds that can never be a footprint
+     * source, as matched by {@link SHAPE_SELECTOR}. Empty whenever the layer
+     * drew a path (the fault is then missing geometry, not the wrong element)
+     * and whenever it drew no matched shape at all.
+     */
+    unusableElementKinds: string[];
+}
+export type VenueContourExtraction = VenueContourRing | VenueContourUnusable;
+/** Resolves a `data-index` to the generated mesh the renderer draws that path from. */
+export type GetFpPathMesh = (index: number) => FpPathMesh | undefined;
+/**
+ * Extracts one plan-local ring from a venue's scene layer.
+ *
+ * Geometry comes from the same source the renderer draws from: a `<path>` is
+ * read through its `data-index` mesh (`window.__fpPaths`), never by parsing `d`,
+ * and coordinates are taken verbatim — no SVG transform or viewBox scaling is
+ * applied, matching `Box.fromSvg` and `meshToShapeDef`. A path the renderer
+ * cannot draw therefore yields no contour, and the caller falls back per §6 of
+ * the data contract.
+ *
+ * The returned ring is a candidate only; `parseVenues` validates it.
+ */
+export declare function extractVenueContour(root: SVGElement, getMesh?: GetFpPathMesh): VenueContourExtraction;
+//# sourceMappingURL=venue-contour.d.ts.map

package/dist/esm/components/Maplibre/utils/venue-contour.fixture.d.ts

@@ -0,0 +1,18 @@
+export declare const splitVenueLayerSvg = "\n  <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 40 30\">\n    <g data-layer=\"venue-scene\">\n      <path data-index=\"0\" d=\"M 10 5 H 30 V 25 H 10 Z\" />\n    </g>\n  </svg>\n";
+export declare const splitVenueLayerMesh: {
+    positions: number[][];
+    cells: number[][];
+};
+export declare const meshWithHole: {
+    positions: number[][];
+    cells: number[][];
+};
+export declare const meshWithMultipleRings: {
+    positions: number[][];
+    cells: number[][];
+};
+export declare const nonManifoldMesh: {
+    positions: number[][];
+    cells: number[][];
+};
+//# sourceMappingURL=venue-contour.fixture.d.ts.map

package/dist/esm/components/Maplibre/utils/venue-contour.fixture.js

@@ -0,0 +1,69 @@
+export const splitVenueLayerSvg = `
+  <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 40 30">
+    <g data-layer="venue-scene">
+      <path data-index="0" d="M 10 5 H 30 V 25 H 10 Z" />
+    </g>
+  </svg>
+`;
+export const splitVenueLayerMesh = {
+    positions: [
+        [10, 5],
+        [30, 5],
+        [30, 25],
+        [10, 25],
+    ],
+    cells: [
+        [0, 1, 2],
+        [0, 2, 3],
+    ],
+};
+export const meshWithHole = {
+    positions: [
+        [0, 0],
+        [20, 0],
+        [20, 20],
+        [0, 20],
+        [5, 5],
+        [15, 5],
+        [15, 15],
+        [5, 15],
+    ],
+    cells: [
+        [0, 1, 5],
+        [0, 5, 4],
+        [1, 2, 6],
+        [1, 6, 5],
+        [2, 3, 7],
+        [2, 7, 6],
+        [3, 0, 4],
+        [3, 4, 7],
+    ],
+};
+export const meshWithMultipleRings = {
+    positions: [
+        [0, 0],
+        [10, 0],
+        [0, 10],
+        [20, 0],
+        [30, 0],
+        [20, 10],
+    ],
+    cells: [
+        [0, 1, 2],
+        [3, 4, 5],
+    ],
+};
+export const nonManifoldMesh = {
+    positions: [
+        [0, 0],
+        [10, 0],
+        [5, 10],
+        [5, -10],
+        [15, 5],
+    ],
+    cells: [
+        [0, 1, 2],
+        [1, 0, 3],
+        [0, 1, 4],
+    ],
+};