@faclon-labs/app-sdk 0.1.0 → 0.3.0

package/vendor/map-engine/maplibre/deck-host.js

@@ -0,0 +1,401 @@
+import { tokenFor, volumeOf } from '../layers/layers.js';
+import { volumeMesh } from '../spatial/volume-mesh.js';
+/** Default loader: the real deck.gl, split into its own chunks so 2D maps never download it. */
+export async function loadDeck() {
+    const [mapbox, layers, mesh] = await Promise.all([import('@deck.gl/mapbox'), import('@deck.gl/layers'), import('@deck.gl/mesh-layers')]);
+    return {
+        MapboxOverlay: mapbox.MapboxOverlay,
+        ScatterplotLayer: layers.ScatterplotLayer,
+        IconLayer: layers.IconLayer,
+        PathLayer: layers.PathLayer,
+        LineLayer: layers.LineLayer,
+        TextLayer: layers.TextLayer,
+        ScenegraphLayer: mesh.ScenegraphLayer,
+        SimpleMeshLayer: mesh.SimpleMeshLayer,
+    };
+}
+/**
+ * Version shim (MapLibre v6 × deck.gl 9.4): deck.gl's interleaved mode reads MapLibre's private `map.transform`
+ * (height, elevation, _nearZ, _farZ). MapLibre v6 moved the transform under `map._camera` and renamed the planes
+ * to nearZ/farZ. When `map.transform` is missing, define a read-only view onto the v6 transform. Delete this once
+ * deck.gl supports MapLibre v6 natively.
+ */
+export function shimTransformForDeck(map) {
+    const m = map;
+    if (m.transform !== undefined)
+        return;
+    const t = () => m._camera?.transform ?? m.painter?.transform;
+    if (!t())
+        return;
+    const view = {
+        get height() {
+            return t()?.height;
+        },
+        get elevation() {
+            return t()?.elevation;
+        },
+        get _nearZ() {
+            return t()?.nearZ ?? t()?._nearZ;
+        },
+        get _farZ() {
+            return t()?.farZ ?? t()?._farZ;
+        },
+    };
+    Object.defineProperty(map, 'transform', { get: () => view, configurable: true });
+}
+/** Layers this host draws instead of MapLibre: anything at a height, and models. */
+export function hostedByDeck(layer) {
+    const t = layer.visualization.type;
+    return t === 'model' || t === 'volume' || ((t === 'marker' || t === 'line' || t === 'track') && layer.visualization.elevation !== undefined);
+}
+/** Smallest on-screen length of a model, so platforms stay visible when zoomed out. */
+const MIN_MODEL_PIXELS = 36;
+function rgba(color, alpha = 1) {
+    const hex = (color ?? '#4CC3FF').replace('#', '');
+    const full = hex.length === 3 ? hex.split('').map((c) => c + c).join('') : hex.slice(0, 6);
+    const n = Number.parseInt(full, 16);
+    return [(n >> 16) & 255, (n >> 8) & 255, n & 255, Math.round(255 * Math.max(0, Math.min(1, alpha)))];
+}
+const num = (v) => (typeof v === 'number' && Number.isFinite(v) ? v : typeof v === 'string' && v.trim() !== '' && Number.isFinite(Number(v)) ? Number(v) : undefined);
+export class DeckHost {
+    env;
+    load;
+    modules = null;
+    overlay = null;
+    loading = null;
+    destroyed = false;
+    hosted = new Map();
+    warnedEllipsoid = false;
+    /** Longest side of each model file, in its own units, once loaded (sizes models in metres and pixels). */
+    extents = new Map();
+    /**
+     * Placed points per layer, keyed by the scene object: the renderer replaces only objects that changed, so a
+     * frame recomputes heights for those alone. Cleared when the layer definition or the ground changes.
+     */
+    placed = new Map();
+    /** Ground heights by position (terrain lookups are not free); cleared when terrain tiles arrive. */
+    groundCache = new Map();
+    constructor(env, load = loadDeck) {
+        this.env = env;
+        this.load = load;
+    }
+    /** Sets (or replaces) what one engine layer shows. */
+    setLayer(layer, objects) {
+        this.hosted.set(layer.id, { layer, objects });
+        this.render();
+    }
+    removeLayer(id) {
+        if (this.hosted.delete(id))
+            this.render();
+    }
+    has(id) {
+        return this.hosted.has(id);
+    }
+    /** Heights depend on the ground: recompute after terrain loads or changes. */
+    refresh() {
+        this.groundCache.clear();
+        this.placed.clear();
+        if (this.hosted.size)
+            this.render();
+    }
+    /** The top object under a screen point among deck.gl-drawn layers. */
+    pick(x, y, radius) {
+        const hit = this.overlay?.pickObject({ x, y, radius });
+        const so = hit?.object?.so;
+        return so ? { objectId: so.object.objectId, layerId: so.layerId } : null;
+    }
+    destroy() {
+        this.destroyed = true;
+        if (this.overlay) {
+            try {
+                this.env.removeControl(this.overlay);
+                this.overlay.finalize();
+            }
+            catch {
+                // Releasing must always complete.
+            }
+        }
+        this.overlay = null;
+        this.hosted.clear();
+    }
+    render() {
+        if (this.destroyed)
+            return;
+        if (!this.modules) {
+            if (!this.hosted.size)
+                return;
+            this.loading ??= this.load().then((m) => {
+                if (this.destroyed)
+                    return;
+                this.modules = m;
+                this.overlay = new m.MapboxOverlay({ interleaved: true, layers: [] });
+                this.env.addControl(this.overlay);
+                this.render();
+            }, (e) => this.env.warn(new Error(`3D layers could not load (deck.gl): ${e instanceof Error ? e.message : String(e)}`)));
+            return;
+        }
+        const layers = [...this.hosted.values()].sort((a, b) => a.layer.zIndex - b.layer.zIndex).flatMap(({ layer, objects }) => (layer.visible ? this.deckLayers(layer, objects) : []));
+        this.overlay.setProps({ layers });
+    }
+    meshes = new Map();
+    meshFor(key, v) {
+        let mesh = this.meshes.get(key);
+        if (!mesh)
+            this.meshes.set(key, (mesh = volumeMesh({ shape: v.shape, beamWidth: v.beamWidth, minElevation: v.minElevation, maxElevation: v.maxElevation })));
+        return mesh;
+    }
+    /** Height of an object in the map's metres (ADR-028), and the ground under it. */
+    place(layer, lng, lat, altitude) {
+        const key = `${lng.toFixed(6)},${lat.toFixed(6)}`;
+        let ground = this.groundCache.get(key);
+        if (ground === undefined) {
+            ground = this.env.ground(lng, lat);
+            if (this.groundCache.size > 200_000)
+                this.groundCache.clear();
+            this.groundCache.set(key, ground);
+        }
+        const e = layer.visualization.elevation;
+        if (!e || altitude === undefined)
+            return { z: ground, ground };
+        const k = this.env.terrainExaggeration();
+        const lift = e.exaggeration ?? 1;
+        if (e.reference === 'agl')
+            return { z: ground + altitude * k * lift, ground };
+        if (e.reference === 'ellipsoid' && !this.warnedEllipsoid) {
+            this.warnedEllipsoid = true;
+            this.env.warn(new Error(`layer ${layer.id}: ellipsoid heights are drawn as sea-level heights (no geoid model in this renderer; up to ~100 m off)`));
+        }
+        const above = altitude * k - ground; // height above the drawn ground
+        return { z: ground + above * lift, ground };
+    }
+    altitudeOf(layer, so, alt) {
+        const e = layer.visualization.elevation;
+        if (e?.from === 'property')
+            return num(so.object.properties?.[e.property]);
+        return alt;
+    }
+    points(layer, objects) {
+        let cache = this.placed.get(layer.id);
+        if (!cache || cache.layer !== layer)
+            this.placed.set(layer.id, (cache = { layer, items: new WeakMap() }));
+        const out = [];
+        for (const so of objects) {
+            const known = cache.items.get(so);
+            if (known) {
+                out.push(known);
+                continue;
+            }
+            const g = so.object.geometry;
+            if (g.type !== 'Point')
+                continue;
+            const { longitude: lng, latitude: lat, altitude } = g.coordinates;
+            const { z, ground } = this.place(layer, lng, lat, this.altitudeOf(layer, so, altitude));
+            const item = { so, at: [lng, lat, z], ground };
+            cache.items.set(so, item);
+            out.push(item);
+        }
+        return out;
+    }
+    paths(layer, objects) {
+        const out = [];
+        for (const so of objects) {
+            const g = so.object.geometry;
+            const lines = g.type === 'LineString' ? [g.coordinates] : g.type === 'MultiLineString' ? g.coordinates : [];
+            for (const line of lines) {
+                out.push({ so, path: line.map((p) => [p.longitude, p.latitude, this.place(layer, p.longitude, p.latitude, this.altitudeOf(layer, so, p.altitude)).z]) });
+            }
+        }
+        return out;
+    }
+    deckLayers(layer, objects) {
+        const m = this.modules;
+        const t = this.env.theme;
+        const vz = layer.visualization;
+        const rules = vz.style;
+        const id = (part) => `me3d:${layer.id}:${part}`;
+        const color = (so, fallback) => {
+            if (so.selected)
+                return rgba(t.selectionColor);
+            return rgba(tokenFor(rules, 'color', so.object.properties, fallback), tokenFor(rules, 'opacity', so.object.properties, 1));
+        };
+        const triggers = objects; // a new list after every scene change: deck re-reads accessors
+        const out = [];
+        if (vz.type === 'line' || vz.type === 'track') {
+            const data = this.paths(layer, objects);
+            out.push(new m.PathLayer({
+                id: id('path'),
+                data,
+                getPath: (d) => d.path,
+                getColor: (d) => color(d.so, vz.type === 'track' ? t.trackColor : t.lineColor),
+                getWidth: (d) => tokenFor(rules, 'size', d.so.object.properties, 3) + (d.so.selected ? 2 : 0),
+                widthUnits: 'pixels',
+                capRounded: true,
+                jointRounded: true,
+                pickable: true,
+                updateTriggers: { getColor: triggers, getWidth: triggers },
+            }));
+            return out;
+        }
+        const data = this.points(layer, objects);
+        const e = vz.elevation;
+        if (e?.shadow) {
+            out.push(new m.ScatterplotLayer({
+                id: id('shadow'),
+                data,
+                getPosition: (d) => [d.at[0], d.at[1], d.ground],
+                getRadius: 5,
+                radiusUnits: 'pixels',
+                getFillColor: [0, 0, 0, 70],
+                updateTriggers: { getPosition: triggers },
+            }));
+        }
+        if (e?.stems) {
+            out.push(new m.LineLayer({
+                id: id('stems'),
+                data,
+                getSourcePosition: (d) => [d.at[0], d.at[1], d.ground],
+                getTargetPosition: (d) => d.at,
+                getColor: (d) => [...color(d.so, t.markerColor).slice(0, 3), 150],
+                getWidth: 1.5,
+                widthUnits: 'pixels',
+                updateTriggers: { getSourcePosition: triggers, getTargetPosition: triggers, getColor: triggers },
+            }));
+        }
+        if (vz.type === 'volume') {
+            // One mesh per distinct shape (dome, or wedge beam and elevation limits); scaled by range, turned by azimuth.
+            const groups = new Map();
+            for (const d of data) {
+                const v = volumeOf(vz.volume, d.so.object.properties);
+                if (!v)
+                    continue;
+                const key = `${v.shape}|${v.beamWidth}|${v.minElevation}|${v.maxElevation}`;
+                let g = groups.get(key);
+                if (!g)
+                    groups.set(key, (g = { mesh: this.meshFor(key, v), items: [] }));
+                g.items.push({ d, v });
+            }
+            const k = this.env.terrainExaggeration();
+            let i = 0;
+            for (const { mesh, items } of groups.values()) {
+                out.push(new m.SimpleMeshLayer({
+                    id: id(`volume-${i++}`),
+                    data: items,
+                    mesh: { positions: { value: mesh.positions, size: 3 }, normals: { value: mesh.normals, size: 3 } },
+                    getPosition: (x) => x.d.at,
+                    // Heights follow the terrain's exaggeration so a volume keeps its relation to the ground.
+                    getScale: (x) => [x.v.range, x.v.range, x.v.range * k],
+                    getOrientation: (x) => [0, -x.v.azimuth, 0],
+                    getColor: (x) => [...color(x.d.so, t.fillColor).slice(0, 3), x.d.so.selected ? 110 : 60],
+                    parameters: { depthWriteEnabled: false, cullMode: 'none' },
+                    pickable: true,
+                    updateTriggers: { getPosition: triggers, getScale: triggers, getOrientation: triggers, getColor: triggers },
+                }));
+            }
+            return out;
+        }
+        if (vz.type === 'model') {
+            // One scenegraph layer per model file (per-rule models choose by style.modelUrl).
+            const byUrl = new Map();
+            for (const d of data) {
+                const url = tokenFor(rules, 'modelUrl', d.so.object.properties, vz.model?.url ?? '');
+                if (url)
+                    byUrl.set(url, [...(byUrl.get(url) ?? []), d]);
+            }
+            const model = vz.model ?? {};
+            const axis = model.axis ?? {};
+            const angle = (d, prop) => (prop ? (num(d.so.object.properties?.[prop]) ?? 0) : 0);
+            let i = 0;
+            for (const [url, list] of byUrl) {
+                const extent = this.extents.get(url);
+                out.push(new m.ScenegraphLayer({
+                    id: id(`model-${i++}`),
+                    data: list,
+                    scenegraph: url,
+                    // Learn the model's size when it loads (deck.gl's default scene choice, plus measuring it once).
+                    getScene: (gltf) => {
+                        const scene = gltf && gltf.scenes ? (typeof gltf.scene === 'object' ? gltf.scene : gltf.scenes[Number(gltf.scene ?? 0)]) : gltf;
+                        const bounds = scene?.getBounds?.();
+                        if (bounds && !this.extents.has(url)) {
+                            const longest = Math.max(...bounds[1].map((v, k) => v - bounds[0][k]));
+                            if (longest > 0) {
+                                this.extents.set(url, longest);
+                                queueMicrotask(() => this.render());
+                            }
+                        }
+                        return scene;
+                    },
+                    getPosition: (d) => d.at,
+                    // deck.gl: [pitch, yaw, roll] in degrees; yaw turns counter-clockwise, heading clockwise from north.
+                    // deck.gl takes a model's z as up: roll 90 stands a glTF file (+Y up) upright, yaw 180 turns its front
+                    // (+Z) to heading 0; deck's yaw runs counter-clockwise, headings clockwise.
+                    getOrientation: (d) => [(axis.pitch ?? 0) + angle(d, model.pitchProperty), 180 + (axis.yaw ?? 0) - angle(d, model.headingProperty), 90 + (axis.roll ?? 0) + angle(d, model.rollProperty)],
+                    getColor: (d) => (d.so.selected ? rgba(t.selectionColor) : [255, 255, 255, 255]),
+                    // sizeMeters is the model's real length; deck.gl scales model units, so divide by the model's length.
+                    sizeScale: extent && model.sizeMeters ? model.sizeMeters / extent : 1,
+                    // deck.gl's minimum is per model unit: keep the whole model at least ~36 px long when zoomed out.
+                    sizeMinPixels: extent ? MIN_MODEL_PIXELS / extent : 0,
+                    _lighting: 'pbr',
+                    pickable: true,
+                    updateTriggers: { getPosition: triggers, getOrientation: triggers, getColor: triggers },
+                }));
+            }
+        }
+        else {
+            const size = vz.icon?.size ?? 18;
+            const withImages = data.filter((d) => tokenFor(rules, 'imageUrl', d.so.object.properties, vz.icon?.imageUrl ?? ''));
+            const dots = data.filter((d) => !withImages.includes(d));
+            if (withImages.length) {
+                out.push(new m.IconLayer({
+                    id: id('icons'),
+                    data: withImages,
+                    getPosition: (d) => d.at,
+                    getIcon: (d) => ({ url: tokenFor(rules, 'imageUrl', d.so.object.properties, vz.icon?.imageUrl ?? ''), width: 64, height: 64, id: tokenFor(rules, 'imageUrl', d.so.object.properties, vz.icon?.imageUrl ?? '') }),
+                    getSize: (d) => size + (d.so.selected ? 6 : 0),
+                    sizeUnits: 'pixels',
+                    billboard: true,
+                    pickable: true,
+                    updateTriggers: { getPosition: triggers, getSize: triggers },
+                }));
+            }
+            if (dots.length) {
+                out.push(new m.ScatterplotLayer({
+                    id: id('dots'),
+                    data: dots,
+                    getPosition: (d) => d.at,
+                    getRadius: (d) => tokenFor(rules, 'size', d.so.object.properties, size / 2) + (d.so.selected ? 3 : 0),
+                    radiusUnits: 'pixels',
+                    billboard: true,
+                    stroked: true,
+                    getFillColor: (d) => color(d.so, t.markerColor),
+                    getLineColor: (d) => (d.so.selected ? rgba(t.selectionColor) : rgba(tokenFor(rules, 'strokeColor', d.so.object.properties, '#0B100E'))),
+                    lineWidthUnits: 'pixels',
+                    getLineWidth: 1.5,
+                    pickable: true,
+                    updateTriggers: { getPosition: triggers, getRadius: triggers, getFillColor: triggers, getLineColor: triggers },
+                }));
+            }
+        }
+        const font = this.env.font();
+        if (vz.label && font) {
+            const label = vz.label;
+            out.push(new m.TextLayer({
+                id: id('labels'),
+                data,
+                getPosition: (d) => d.at,
+                getText: (d) => String(d.so.object.properties?.[label.property] ?? ''),
+                getSize: label.size ?? 12,
+                getColor: rgba(label.color ?? t.labelColor),
+                fontFamily: font,
+                fontSettings: { sdf: true },
+                outlineWidth: 3,
+                outlineColor: rgba(label.haloColor ?? t.labelHalo),
+                getPixelOffset: [0, 16],
+                getTextAnchor: 'middle',
+                getAlignmentBaseline: 'top',
+                billboard: true,
+                updateTriggers: { getPosition: triggers, getText: triggers },
+            }));
+        }
+        return out;
+    }
+}

package/vendor/map-engine/maplibre/icons.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Built-in marker shapes as signed-distance-field images, generated in code: no image files, no DOM.
+ * SDF images can be recoloured by style rules (`icon-color`) and stay sharp when scaled.
+ */
+import type { IconShape } from '../core/types.js';
+export declare const ICON_PIXELS = 32;
+/**
+ * RGBA image whose alpha encodes the SDF the way MapLibre expects (edge at 0.75, `buffer` px of falloff).
+ */
+export declare function shapeImage(shape: IconShape, size?: number, buffer?: number): {
+    width: number;
+    height: number;
+    data: Uint8Array;
+};
+export declare const shapeImageId: (shape: IconShape) => string;
+/** Stable id for an image URL (FNV-1a), so the same image is added once per map. */
+export declare function urlImageId(url: string): string;

package/vendor/map-engine/maplibre/icons.js

@@ -0,0 +1,65 @@
+/** Unit-square polygons ([-1, 1], y down = screen down). The arrow points north at rotation 0. */
+const POLYGONS = {
+    square: [[-0.78, -0.78], [0.78, -0.78], [0.78, 0.78], [-0.78, 0.78]],
+    triangle: [[0, -0.92], [0.9, 0.78], [-0.9, 0.78]],
+    diamond: [[0, -0.98], [0.98, 0], [0, 0.98], [-0.98, 0]],
+    arrow: [[0, -1], [0.78, 0.9], [0, 0.42], [-0.78, 0.9]],
+};
+export const ICON_PIXELS = 32;
+function segmentDistance(px, py, ax, ay, bx, by) {
+    const dx = bx - ax;
+    const dy = by - ay;
+    const t = Math.max(0, Math.min(1, ((px - ax) * dx + (py - ay) * dy) / (dx * dx + dy * dy)));
+    return Math.hypot(px - (ax + t * dx), py - (ay + t * dy));
+}
+function inside(px, py, poly) {
+    let c = false;
+    for (let i = 0, j = poly.length - 1; i < poly.length; j = i++) {
+        const [xi, yi] = poly[i];
+        const [xj, yj] = poly[j];
+        if (yi > py !== yj > py && px < ((xj - xi) * (py - yi)) / (yj - yi) + xi)
+            c = !c;
+    }
+    return c;
+}
+/** Signed distance in unit space: negative inside the shape. */
+function signedDistance(shape, x, y) {
+    if (shape === 'circle')
+        return Math.hypot(x, y) - 0.82;
+    const poly = POLYGONS[shape];
+    let d = Infinity;
+    for (let i = 0; i < poly.length; i++) {
+        const [ax, ay] = poly[i];
+        const [bx, by] = poly[(i + 1) % poly.length];
+        d = Math.min(d, segmentDistance(x, y, ax, ay, bx, by));
+    }
+    return inside(x, y, poly) ? -d : d;
+}
+/**
+ * RGBA image whose alpha encodes the SDF the way MapLibre expects (edge at 0.75, `buffer` px of falloff).
+ */
+export function shapeImage(shape, size = ICON_PIXELS, buffer = 6) {
+    const full = size + buffer * 2;
+    const data = new Uint8Array(full * full * 4);
+    const half = size / 2;
+    const radius = buffer + 2;
+    for (let py = 0; py < full; py++) {
+        for (let px = 0; px < full; px++) {
+            const ux = (px + 0.5 - full / 2) / half;
+            const uy = (py + 0.5 - full / 2) / half;
+            const dPixels = signedDistance(shape, ux, uy) * half;
+            const a = Math.max(0, Math.min(255, Math.round(255 - 255 * (dPixels / radius + 0.25))));
+            const i = (py * full + px) * 4;
+            data[i] = data[i + 1] = data[i + 2] = data[i + 3] = a;
+        }
+    }
+    return { width: full, height: full, data };
+}
+export const shapeImageId = (shape) => `me-shape-${shape}`;
+/** Stable id for an image URL (FNV-1a), so the same image is added once per map. */
+export function urlImageId(url) {
+    let h = 0x811c9dc5;
+    for (let i = 0; i < url.length; i++)
+        h = Math.imul(h ^ url.charCodeAt(i), 0x01000193);
+    return `me-img-${(h >>> 0).toString(36)}`;
+}

package/vendor/map-engine/maplibre/index.d.ts

@@ -0,0 +1,3 @@
+export { MapLibreRenderer, type MapLibreRendererOptions } from './renderer.js';
+export { DEFAULT_THEME, type RendererTheme } from './style.js';
+export type { MapLike, MapLibreModuleLike } from './map-like.js';

package/vendor/map-engine/maplibre/index.js

@@ -0,0 +1,2 @@
+export { MapLibreRenderer } from './renderer.js';
+export { DEFAULT_THEME } from './style.js';

package/vendor/map-engine/maplibre/map-like.d.ts

@@ -0,0 +1,56 @@
+/**
+ * The slice of MapLibre GL JS the adapter uses, derived from MapLibre's own types (type-only import: no
+ * runtime cost, and the slice cannot drift from the real API). Tests drive a fake that fits this slice,
+ * because jsdom has no WebGL.
+ */
+import type * as GeoJSON from 'geojson';
+import type { Map as MapLibreMap, MapOptions } from 'maplibre-gl';
+export type MapLike = Pick<MapLibreMap, 'on' | 'off' | 'addSource' | 'getSource' | 'removeSource' | 'addLayer' | 'getLayer' | 'removeLayer' | 'moveLayer' | 'setLayoutProperty' | 'setFeatureState' | 'removeFeatureState' | 'queryRenderedFeatures' | 'jumpTo' | 'easeTo' | 'getCenter' | 'getZoom' | 'getBearing' | 'getPitch' | 'getBounds' | 'getCanvas' | 'getContainer' | 'resize' | 'remove' | 'addImage' | 'hasImage' | 'loadImage' | 'project' | 'setStyle' | 'isSourceLoaded' | 'setProjection' | 'setTerrain' | 'setSky' | 'queryTerrainElevation' | 'addControl' | 'removeControl'>;
+/** What the adapter needs from the `maplibre-gl` module: just the Map constructor. */
+export interface MapLibreModuleLike {
+    Map: new (options: MapOptions) => MapLike;
+    /** Where MapLibre loads its web worker from (v6). Optional so older modules and fakes still fit. */
+    setWorkerUrl?: (url: string) => void;
+    /** Custom URL schemes (pmtiles://, contour tiles). Optional so fakes without it still fit. */
+    addProtocol?: (id: string, handler: never) => void;
+}
+/** An image source (MapLibre places a picture by four corners). */
+export interface ImageSourceLike {
+    updateImage(options: {
+        url: string;
+        coordinates?: Array<[number, number]>;
+    }): unknown;
+    setCoordinates(coordinates: Array<[number, number]>): unknown;
+}
+/** The GeoJSON source methods the adapter calls (MapLibre's `getSource` returns a generic Source). */
+export interface GeoJSONSourceLike {
+    setData(data: GeoJSON.FeatureCollection): Promise<void> | unknown;
+    updateData?(diff: {
+        removeAll?: boolean;
+        remove?: Array<string | number>;
+        add?: GeoJSON.Feature[];
+    }): Promise<void> | unknown;
+    getClusterExpansionZoom?(clusterId: number): Promise<number>;
+}
+/** Fields the adapter reads from MapLibre mouse events and rendered features. */
+export interface MapMouseEventLike {
+    point: {
+        x: number;
+        y: number;
+    };
+    lngLat: {
+        lng: number;
+        lat: number;
+    };
+}
+export interface RenderedFeatureLike {
+    id?: string | number;
+    properties: Record<string, unknown>;
+    layer: {
+        id: string;
+    };
+    geometry?: {
+        type: string;
+        coordinates: unknown;
+    };
+}

package/vendor/map-engine/maplibre/map-like.js

@@ -0,0 +1 @@
+export {};