@sjvair/monitor-map 3.0.3 → 3.0.5

package/dist/lib/ev-stations/ev-stations-cluster-renderer.js

@@ -1,118 +1,131 @@
-import { mountPopup as e } from "../map/utils.js";
-import { mapManager as t } from "../map/map.svelte.js";
-import { clickManager as n } from "../map/integrations/click-manager.js";
-import { EV_STATION_LEVELS as r } from "./ev-station-icons.js";
-import i from "./components/EvStationClusterTooltip.js";
-//#region src/lib/ev-stations/ev-stations-cluster-renderer.ts
-function a(t) {
-	let n = t.features?.[0];
-	if (n) return e(i, { feature: n }, t.lngLat);
+import { mapManager } from "../map/map.svelte.ts";
+import { mountPopup } from "../map/utils.ts";
+import { clickManager } from "../map/integrations/click-manager.ts";
+import { EV_STATION_LEVELS } from "./ev-station-icons.ts";
+import EvStationClusterTooltip from "./components/EvStationClusterTooltip.svelte";
+function clusterTooltip(evt) {
+    const feature = evt.features?.[0];
+    if (!feature)
+        return;
+    return mountPopup(EvStationClusterTooltip, { feature }, evt.lngLat);
+}
+export class EvStationsClusterRenderer {
+    ctx;
+    _levels = [];
+    constructor(ctx) {
+        this.ctx = ctx;
+    }
+    apply(stationClickHandler) {
+        if (!mapManager.map)
+            return;
+        for (const level of Object.keys(EV_STATION_LEVELS)) {
+            const sourceId = `${this.ctx.referenceId}-${level}`;
+            const features = this.ctx.featuresByLevel[level] ?? [];
+            const { bg } = EV_STATION_LEVELS[level];
+            const clusterBg = bg.replace("rgb(", "rgba(").replace(")", ", 0.6)");
+            mapManager.map.addSource(sourceId, {
+                type: "geojson",
+                promoteId: "id",
+                data: { type: "FeatureCollection", features },
+                cluster: true,
+                clusterRadius: 40,
+                clusterMaxZoom: 9
+            });
+            mapManager.map.addLayer({
+                id: `${sourceId}-cluster-circle`,
+                type: "circle",
+                source: sourceId,
+                filter: ["has", "point_count"],
+                paint: {
+                    "circle-color": clusterBg,
+                    "circle-radius": ["step", ["get", "point_count"], 15, 10, 20, 25, 25]
+                }
+            }, this.ctx.beforeLayer);
+            mapManager.map.addLayer({
+                id: `${sourceId}-cluster-label`,
+                type: "symbol",
+                source: sourceId,
+                filter: ["has", "point_count"],
+                layout: {
+                    "text-field": ["get", "point_count_abbreviated"],
+                    "text-size": 12,
+                    "text-allow-overlap": true,
+                    "text-ignore-placement": true
+                },
+                paint: { "text-color": "#ffffff" }
+            }, this.ctx.beforeLayer);
+            mapManager.map.addLayer({
+                id: `${sourceId}-unclustered`,
+                type: "symbol",
+                source: sourceId,
+                filter: ["!", ["has", "point_count"]],
+                layout: {
+                    "icon-image": `ev-station-${level}`,
+                    "icon-allow-overlap": true,
+                    "icon-ignore-placement": true,
+                    "icon-size": 1
+                },
+                paint: {}
+            }, this.ctx.beforeLayer);
+            const circleLayerId = `${sourceId}-cluster-circle`;
+            const unclusteredLayerId = `${sourceId}-unclustered`;
+            if (!this.ctx.tooltipManager.has(circleLayerId)) {
+                this.ctx.tooltipManager.register(circleLayerId, clusterTooltip);
+            }
+            clickManager.register([circleLayerId], this.makeClusterClickHandler(sourceId));
+            clickManager.register([unclusteredLayerId], stationClickHandler);
+            this._levels.push(level);
+        }
+    }
+    remove() {
+        if (!mapManager.map)
+            return;
+        for (const level of this._levels) {
+            const sourceId = `${this.ctx.referenceId}-${level}`;
+            const layerIds = [
+                `${sourceId}-cluster-circle`,
+                `${sourceId}-cluster-label`,
+                `${sourceId}-unclustered`
+            ];
+            for (const layerId of layerIds) {
+                clickManager.unregister([layerId]);
+                if (mapManager.map.getLayer(layerId)) {
+                    mapManager.map.removeLayer(layerId);
+                }
+            }
+            if (mapManager.map.getSource(sourceId)) {
+                mapManager.map.removeSource(sourceId);
+            }
+        }
+        this._levels = [];
+    }
+    get unclusteredLayerIds() {
+        return this._levels.map((level) => `${this.ctx.referenceId}-${level}-unclustered`);
+    }
+    syncFeatures() {
+        if (!mapManager.map)
+            return;
+        for (const level of this._levels) {
+            const sourceId = `${this.ctx.referenceId}-${level}`;
+            mapManager.setDataSource(sourceId, this.ctx.featuresByLevel[level] ?? []);
+        }
+    }
+    makeClusterClickHandler(sourceId) {
+        return async (features) => {
+            try {
+                const feature = features[0];
+                if (!feature?.properties?.cluster_id)
+                    return;
+                const source = mapManager.map?.getSource(sourceId);
+                if (!source)
+                    return;
+                const zoom = await source.getClusterExpansionZoom(feature.properties.cluster_id);
+                const coords = feature.geometry.coordinates;
+                mapManager.map?.easeTo({ center: coords, zoom });
+            }
+            catch (err) {
+                console.error("EvStations: cluster expansion zoom failed", err);
+            }
+        };
+    }
 }
-var o = class {
-	ctx;
-	_levels = [];
-	constructor(e) {
-		this.ctx = e;
-	}
-	apply(e) {
-		if (t.map) for (let i of Object.keys(r)) {
-			let o = `${this.ctx.referenceId}-${i}`, s = this.ctx.featuresByLevel[i] ?? [], { bg: c } = r[i], l = c.replace("rgb(", "rgba(").replace(")", ", 0.6)");
-			t.map.addSource(o, {
-				type: "geojson",
-				promoteId: "id",
-				data: {
-					type: "FeatureCollection",
-					features: s
-				},
-				cluster: !0,
-				clusterRadius: 40,
-				clusterMaxZoom: 9
-			}), t.map.addLayer({
-				id: `${o}-cluster-circle`,
-				type: "circle",
-				source: o,
-				filter: ["has", "point_count"],
-				paint: {
-					"circle-color": l,
-					"circle-radius": [
-						"step",
-						["get", "point_count"],
-						15,
-						10,
-						20,
-						25,
-						25
-					]
-				}
-			}, this.ctx.beforeLayer), t.map.addLayer({
-				id: `${o}-cluster-label`,
-				type: "symbol",
-				source: o,
-				filter: ["has", "point_count"],
-				layout: {
-					"text-field": ["get", "point_count_abbreviated"],
-					"text-size": 12,
-					"text-allow-overlap": !0,
-					"text-ignore-placement": !0
-				},
-				paint: { "text-color": "#ffffff" }
-			}, this.ctx.beforeLayer), t.map.addLayer({
-				id: `${o}-unclustered`,
-				type: "symbol",
-				source: o,
-				filter: ["!", ["has", "point_count"]],
-				layout: {
-					"icon-image": `ev-station-${i}`,
-					"icon-allow-overlap": !0,
-					"icon-ignore-placement": !0,
-					"icon-size": 1
-				},
-				paint: {}
-			}, this.ctx.beforeLayer);
-			let u = `${o}-cluster-circle`, d = `${o}-unclustered`;
-			this.ctx.tooltipManager.has(u) || this.ctx.tooltipManager.register(u, a), n.register([u], this.makeClusterClickHandler(o)), n.register([d], e), this._levels.push(i);
-		}
-	}
-	remove() {
-		if (t.map) {
-			for (let e of this._levels) {
-				let r = `${this.ctx.referenceId}-${e}`, i = [
-					`${r}-cluster-circle`,
-					`${r}-cluster-label`,
-					`${r}-unclustered`
-				];
-				for (let e of i) n.unregister([e]), t.map.getLayer(e) && t.map.removeLayer(e);
-				t.map.getSource(r) && t.map.removeSource(r);
-			}
-			this._levels = [];
-		}
-	}
-	get unclusteredLayerIds() {
-		return this._levels.map((e) => `${this.ctx.referenceId}-${e}-unclustered`);
-	}
-	syncFeatures() {
-		if (t.map) for (let e of this._levels) {
-			let n = `${this.ctx.referenceId}-${e}`;
-			t.setDataSource(n, this.ctx.featuresByLevel[e] ?? []);
-		}
-	}
-	makeClusterClickHandler(e) {
-		return async (n) => {
-			try {
-				let r = n[0];
-				if (!r?.properties?.cluster_id) return;
-				let i = t.map?.getSource(e);
-				if (!i) return;
-				let a = await i.getClusterExpansionZoom(r.properties.cluster_id), o = r.geometry.coordinates;
-				t.map?.easeTo({
-					center: o,
-					zoom: a
-				});
-			} catch (e) {
-				console.error("EvStations: cluster expansion zoom failed", e);
-			}
-		};
-	}
-};
-//#endregion
-export { o as EvStationsClusterRenderer };

package/dist/lib/ev-stations/ev-stations-map-integration.svelte.d.ts

@@ -0,0 +1,31 @@
+import type { FilterSpecification, Map as MaptilerMap } from "@maptiler/sdk";
+import { MapIconLayerIntegration } from "../map/integrations/map-geojson-integration.svelte.ts";
+import { MapDisplayOption } from "../map/integrations/map-display-option.svelte.ts";
+import { TooltipManager } from "../map/integrations/tooltip.svelte.ts";
+import { EvStationIconManager } from "./ev-station-icons.ts";
+import { type EvStationsClusterContext } from "./ev-stations-cluster-renderer.ts";
+import type { EvStationMapFeature, EvStationMarkerProperties } from "./types.ts";
+declare class EvStationsMapIntegration extends MapIconLayerIntegration<EvStationMarkerProperties> implements EvStationsClusterContext {
+    referenceId: string;
+    enabled: boolean;
+    clustered: boolean;
+    icons: EvStationIconManager;
+    tooltipManager: TooltipManager;
+    private renderer;
+    private currentPopup;
+    displayOptions: {
+        lvl2: MapDisplayOption;
+        lvl3: MapDisplayOption;
+    };
+    features: Array<EvStationMapFeature>;
+    featuresByLevel: Record<string, EvStationMapFeature[]>;
+    filters: FilterSpecification;
+    private handleStationClick;
+    get mapLayer(): Parameters<MaptilerMap["addLayer"]>[0];
+    get mapSource(): Parameters<MaptilerMap["addSource"]>[1];
+    constructor();
+    apply(): void;
+    remove(): void;
+}
+export declare const evStationsMapIntegration: EvStationsMapIntegration;
+export type { EvStationsMapIntegration };