@mcp-b/geo-leaflet 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 MCP-B contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/circle-CqXHsyYH.js

@@ -0,0 +1,84 @@
+import { t as __decorate } from "./decorate-DcF3lt7P.js";
+import { findLeafletMap } from "./components/find-leaflet-map.js";
+import * as L from "leaflet";
+import { LitElement, css, html } from "lit";
+import { customElement, property } from "lit/decorators.js";
+//#region src/components/circle/circle.styles.ts
+var circle_styles_default = css`
+  :host {
+    display: none;
+  }
+`;
+//#endregion
+//#region src/components/circle/circle.ts
+let SigveloLeafletCircle = class SigveloLeafletCircle extends LitElement {
+	constructor(..._args) {
+		super(..._args);
+		this.latitude = 0;
+		this.longitude = 0;
+		this.radius = 100;
+		this.fillColor = "#3388ff";
+		this.fillOpacity = .2;
+		this.strokeColor = "#3388ff";
+		this.strokeWidth = 3;
+		this._circle = null;
+		this._mapEl = null;
+	}
+	static {
+		this.styles = [circle_styles_default];
+	}
+	async connectedCallback() {
+		super.connectedCallback();
+		this._mapEl = findLeafletMap(this);
+		if (this._mapEl) {
+			await this._mapEl.mapReady;
+			this._addCircle();
+		}
+	}
+	disconnectedCallback() {
+		super.disconnectedCallback();
+		this._circle?.remove();
+		this._circle = null;
+	}
+	/** @internal */
+	_addCircle() {
+		if (!this._mapEl?.map) return;
+		this._circle = L.circle([this.latitude, this.longitude], {
+			radius: this.radius,
+			fillColor: this.fillColor,
+			fillOpacity: this.fillOpacity,
+			color: this.strokeColor,
+			weight: this.strokeWidth
+		}).addTo(this._mapEl.map);
+	}
+	updated(changed) {
+		if (!this._circle) return;
+		if (changed.has("latitude") || changed.has("longitude")) this._circle.setLatLng([this.latitude, this.longitude]);
+		if (changed.has("radius")) this._circle.setRadius(this.radius);
+		if (changed.has("fillColor") || changed.has("fillOpacity") || changed.has("strokeColor") || changed.has("strokeWidth")) this._circle.setStyle({
+			fillColor: this.fillColor,
+			fillOpacity: this.fillOpacity,
+			color: this.strokeColor,
+			weight: this.strokeWidth
+		});
+	}
+	render() {
+		return html``;
+	}
+};
+__decorate([property({ type: Number })], SigveloLeafletCircle.prototype, "latitude", void 0);
+__decorate([property({ type: Number })], SigveloLeafletCircle.prototype, "longitude", void 0);
+__decorate([property({ type: Number })], SigveloLeafletCircle.prototype, "radius", void 0);
+__decorate([property({ attribute: "fill-color" })], SigveloLeafletCircle.prototype, "fillColor", void 0);
+__decorate([property({
+	attribute: "fill-opacity",
+	type: Number
+})], SigveloLeafletCircle.prototype, "fillOpacity", void 0);
+__decorate([property({ attribute: "stroke-color" })], SigveloLeafletCircle.prototype, "strokeColor", void 0);
+__decorate([property({
+	attribute: "stroke-width",
+	type: Number
+})], SigveloLeafletCircle.prototype, "strokeWidth", void 0);
+SigveloLeafletCircle = __decorate([customElement("sigvelo-leaflet-circle")], SigveloLeafletCircle);
+//#endregion
+export { SigveloLeafletCircle as t };

package/dist/components/choropleth/choropleth.d.ts

@@ -0,0 +1,68 @@
+import { PropertyValues } from "lit";
+import { SigveloElement } from "@mcp-b/wc-support/base/sigvelo-element";
+import { ClassificationMethod, GeoJsonFeatureCollection } from "@mcp-b/geo-support/types";
+
+//#region src/components/choropleth/choropleth.d.ts
+type ChoroplethRow = Readonly<Record<string, string | number | boolean | null>>;
+/**
+ * A classified GeoJSON polygon layer with a coordinated Leaflet legend.
+ * Place it inside a `<sigvelo-leaflet-map>`.
+ *
+ * @tag sigvelo-leaflet-choropleth
+ */
+declare class SigveloLeafletChoropleth extends SigveloElement {
+  static styles: import("lit").CSSResult;
+  /** Trusted GeoJSON supplied by the host application. */
+  data: GeoJsonFeatureCollection;
+  /** Optional GeoJSON URL loaded only when this component is rendered. */
+  src: string;
+  /** Optional bounded rows joined onto feature properties before classification. */
+  rows: readonly ChoroplethRow[] | undefined;
+  /** Feature property used to match a row. */
+  featureKey: string;
+  /** Row property used to match a feature. */
+  dataKey: string;
+  /** Numeric feature property used to classify regions. */
+  property: string;
+  /** Classification algorithm. */
+  method: ClassificationMethod;
+  /** Number of color classes. */
+  numClasses: number;
+  /** Reviewed ColorBrewer scheme name. */
+  colorScheme: string;
+  /** Legend heading. */
+  legendTitle: string;
+  /** Feature property displayed as the region popup heading. */
+  popupTitleProperty: string;
+  /** Label displayed before the classified value in region popups. */
+  popupValueLabel: string;
+  /** Leaflet control position for the legend. */
+  legendPosition: "top-left" | "top-right" | "bottom-left" | "bottom-right";
+  /** Whether polygon features emit click events. */
+  interactive: boolean;
+  /** Fit the parent map to the loaded polygons. */
+  fitBounds: boolean;
+  private sourceData;
+  private sourceLoading;
+  private sourceError;
+  private sourceController?;
+  private sourceRequest;
+  private sourceReady;
+  /** Resolves after the current remote GeoJSON request settles. */
+  get dataReady(): Promise<void>;
+  /** Whether a remote GeoJSON request is active. */
+  get loading(): boolean;
+  /** Bounded loading error for host diagnostics. */
+  get loadError(): string;
+  disconnectedCallback(): void;
+  protected updated(changed: PropertyValues<this>): void;
+  private loadSource;
+  render(): import("lit-html").TemplateResult<1>;
+}
+declare global {
+  interface HTMLElementTagNameMap {
+    "sigvelo-leaflet-choropleth": SigveloLeafletChoropleth;
+  }
+}
+//#endregion
+export { SigveloLeafletChoropleth };

package/dist/components/choropleth/choropleth.js

@@ -0,0 +1,195 @@
+import { t as __decorate } from "../../decorate-DcF3lt7P.js";
+import "../../geojson-DPaCrjMF.js";
+import "../../control-ysNMOWeF.js";
+import { css, html, nothing } from "lit";
+import { customElement, property, state } from "lit/decorators.js";
+import { createClassifyStyle } from "@mcp-b/geo-support/classification";
+import "@mcp-b/geo-support/components/legend/legend";
+import { SigveloElement } from "@mcp-b/wc-support/base/sigvelo-element";
+//#region src/components/choropleth/choropleth.ts
+const emptyData = {
+	type: "FeatureCollection",
+	features: []
+};
+function isFeatureCollection(value) {
+	if (!value || typeof value !== "object" || Reflect.get(value, "type") !== "FeatureCollection") return false;
+	const features = Reflect.get(value, "features");
+	return Array.isArray(features) && features.every((feature) => feature !== null && typeof feature === "object" && Reflect.get(feature, "type") === "Feature" && Reflect.get(feature, "geometry") !== null && typeof Reflect.get(feature, "geometry") === "object");
+}
+function joinRows(data, rows, featureKey, dataKey, property) {
+	if (rows === void 0) return data;
+	const values = new Map(rows.filter((row) => typeof row[dataKey] === "string" && typeof row[property] === "number" && Number.isFinite(row[property])).map((row) => [String(row[dataKey]), row[property]]));
+	return {
+		type: "FeatureCollection",
+		features: data.features.map((feature) => {
+			const properties = { ...feature.properties };
+			delete properties[property];
+			const featureValue = properties[featureKey];
+			if (typeof featureValue === "string") {
+				const value = values.get(featureValue);
+				if (value !== void 0) properties[property] = value;
+			}
+			return {
+				...feature,
+				properties
+			};
+		})
+	};
+}
+let SigveloLeafletChoropleth = class SigveloLeafletChoropleth extends SigveloElement {
+	constructor(..._args) {
+		super(..._args);
+		this.data = emptyData;
+		this.src = "";
+		this.featureKey = "name";
+		this.dataKey = "name";
+		this.property = "density";
+		this.method = "naturalBreaks";
+		this.numClasses = 5;
+		this.colorScheme = "Blues";
+		this.legendTitle = "";
+		this.popupTitleProperty = "name";
+		this.popupValueLabel = "";
+		this.legendPosition = "top-right";
+		this.interactive = true;
+		this.fitBounds = true;
+		this.sourceData = null;
+		this.sourceLoading = false;
+		this.sourceError = "";
+		this.sourceRequest = 0;
+		this.sourceReady = Promise.resolve();
+	}
+	static {
+		this.styles = css`
+    :host {
+      display: contents;
+    }
+
+    .status {
+      max-inline-size: 18rem;
+      padding: 0.5rem 0.625rem;
+      border-radius: 0.375rem;
+      color: CanvasText;
+      background: Canvas;
+      box-shadow: 0 1px 4px rgb(0 0 0 / 24%);
+      font:
+        0.8125rem/1.35 system-ui,
+        sans-serif;
+    }
+  `;
+	}
+	/** Resolves after the current remote GeoJSON request settles. */
+	get dataReady() {
+		return this.sourceReady;
+	}
+	/** Whether a remote GeoJSON request is active. */
+	get loading() {
+		return this.sourceLoading;
+	}
+	/** Bounded loading error for host diagnostics. */
+	get loadError() {
+		return this.sourceError;
+	}
+	disconnectedCallback() {
+		this.sourceController?.abort();
+		super.disconnectedCallback();
+	}
+	updated(changed) {
+		super.updated(changed);
+		if (changed.has("src")) this.loadSource();
+	}
+	loadSource() {
+		this.sourceController?.abort();
+		this.sourceController = void 0;
+		this.sourceData = null;
+		this.sourceError = "";
+		const src = this.src.trim();
+		if (!src) {
+			this.sourceLoading = false;
+			this.sourceReady = Promise.resolve();
+			return;
+		}
+		const request = ++this.sourceRequest;
+		const controller = new AbortController();
+		this.sourceController = controller;
+		this.sourceLoading = true;
+		this.sourceReady = fetch(src, { signal: controller.signal }).then(async (response) => {
+			if (!response.ok) throw new Error(`GeoJSON request failed with status ${response.status}.`);
+			const value = await response.json();
+			if (!isFeatureCollection(value)) throw new Error("The geography source is not a GeoJSON FeatureCollection.");
+			if (request === this.sourceRequest) this.sourceData = value;
+		}).catch((error) => {
+			if (controller.signal.aborted || request !== this.sourceRequest) return;
+			this.sourceError = error instanceof Error ? error.message.slice(0, 240) : "GeoJSON load failed.";
+		}).finally(() => {
+			if (request === this.sourceRequest) this.sourceLoading = false;
+		});
+	}
+	render() {
+		const data = joinRows(this.src ? this.sourceData ?? emptyData : this.data, this.rows, this.featureKey, this.dataKey, this.property);
+		const result = createClassifyStyle(data.features, {
+			property: this.property,
+			method: this.method,
+			numClasses: this.numClasses,
+			colorScheme: this.colorScheme,
+			strokeColor: "#475569",
+			strokeWidth: 1,
+			strokeOpacity: .9,
+			fillOpacity: .84
+		});
+		return html`
+      <sigvelo-leaflet-geojson
+        .data=${data}
+        .styleFunction=${result.styleFunction}
+        .interactive=${this.interactive}
+        .fitBounds=${this.fitBounds}
+        .popupTitleProperty=${this.popupTitleProperty}
+        .popupValueProperty=${this.property}
+        .popupValueLabel=${this.popupValueLabel || this.legendTitle || this.property}
+        fill-color="#64748b"
+        fill-opacity="0.55"
+        stroke-color="#475569"
+        stroke-width="1"
+      ></sigvelo-leaflet-geojson>
+      ${this.sourceLoading || this.sourceError ? html`<sigvelo-leaflet-control position="top-left">
+            <div class="status" role=${this.sourceError ? "alert" : "status"}>
+              ${this.sourceError || "Loading geography…"}
+            </div>
+          </sigvelo-leaflet-control>` : nothing}
+      ${result.colors.length > 0 ? html`<sigvelo-leaflet-control position=${this.legendPosition}>
+            <sigvelo-geo-legend
+              title=${this.legendTitle || this.property}
+              .breaks=${result.breaks}
+              .colors=${result.colors}
+            ></sigvelo-geo-legend>
+          </sigvelo-leaflet-control>` : nothing}
+    `;
+	}
+};
+__decorate([property({ attribute: false })], SigveloLeafletChoropleth.prototype, "data", void 0);
+__decorate([property()], SigveloLeafletChoropleth.prototype, "src", void 0);
+__decorate([property({ attribute: false })], SigveloLeafletChoropleth.prototype, "rows", void 0);
+__decorate([property({ attribute: "feature-key" })], SigveloLeafletChoropleth.prototype, "featureKey", void 0);
+__decorate([property({ attribute: "data-key" })], SigveloLeafletChoropleth.prototype, "dataKey", void 0);
+__decorate([property()], SigveloLeafletChoropleth.prototype, "property", void 0);
+__decorate([property()], SigveloLeafletChoropleth.prototype, "method", void 0);
+__decorate([property({
+	attribute: "num-classes",
+	type: Number
+})], SigveloLeafletChoropleth.prototype, "numClasses", void 0);
+__decorate([property({ attribute: "color-scheme" })], SigveloLeafletChoropleth.prototype, "colorScheme", void 0);
+__decorate([property({ attribute: "legend-title" })], SigveloLeafletChoropleth.prototype, "legendTitle", void 0);
+__decorate([property({ attribute: "popup-title-property" })], SigveloLeafletChoropleth.prototype, "popupTitleProperty", void 0);
+__decorate([property({ attribute: "popup-value-label" })], SigveloLeafletChoropleth.prototype, "popupValueLabel", void 0);
+__decorate([property({ attribute: "legend-position" })], SigveloLeafletChoropleth.prototype, "legendPosition", void 0);
+__decorate([property({ type: Boolean })], SigveloLeafletChoropleth.prototype, "interactive", void 0);
+__decorate([property({
+	attribute: "fit-bounds",
+	type: Boolean
+})], SigveloLeafletChoropleth.prototype, "fitBounds", void 0);
+__decorate([state()], SigveloLeafletChoropleth.prototype, "sourceData", void 0);
+__decorate([state()], SigveloLeafletChoropleth.prototype, "sourceLoading", void 0);
+__decorate([state()], SigveloLeafletChoropleth.prototype, "sourceError", void 0);
+SigveloLeafletChoropleth = __decorate([customElement("sigvelo-leaflet-choropleth")], SigveloLeafletChoropleth);
+//#endregion
+export { SigveloLeafletChoropleth };

package/dist/components/circle/circle.d.ts

@@ -0,0 +1,43 @@
+import { LitElement, PropertyValues } from "lit";
+
+//#region src/components/circle/circle.d.ts
+/**
+ * A circle overlay on a Leaflet map. Must be a child of `<sigvelo-leaflet-map>`.
+ *
+ * @tag sigvelo-leaflet-circle
+ */
+declare class SigveloLeafletCircle extends LitElement {
+  /** @internal */
+  static styles: import("lit").CSSResult[];
+  /** Center latitude. */
+  latitude: number;
+  /** Center longitude. */
+  longitude: number;
+  /** Radius in meters. */
+  radius: number;
+  /** Fill color (CSS color string). */
+  fillColor: string;
+  /** Fill opacity (0-1). */
+  fillOpacity: number;
+  /** Stroke color (CSS color string). */
+  strokeColor: string;
+  /** Stroke width in pixels. */
+  strokeWidth: number;
+  /** @internal */
+  private _circle;
+  /** @internal */
+  private _mapEl;
+  connectedCallback(): Promise<void>;
+  disconnectedCallback(): void;
+  /** @internal */
+  private _addCircle;
+  protected updated(changed: PropertyValues): void;
+  render(): import("lit-html").TemplateResult<1>;
+}
+declare global {
+  interface HTMLElementTagNameMap {
+    "sigvelo-leaflet-circle": SigveloLeafletCircle;
+  }
+}
+//#endregion
+export { SigveloLeafletCircle };

package/dist/components/circle/circle.js

@@ -0,0 +1,2 @@
+import { t as SigveloLeafletCircle } from "../../circle-CqXHsyYH.js";
+export { SigveloLeafletCircle };

package/dist/components/control/control.d.ts

@@ -0,0 +1,43 @@
+import { LitElement } from "lit";
+
+//#region src/components/control/control.d.ts
+/**
+ * A generic control container for a Leaflet map. Wraps arbitrary content
+ * and places it in one of Leaflet's four control corners, stacking properly
+ * with zoom, attribution, and other controls.
+ *
+ * @tag sigvelo-leaflet-control
+ *
+ * @example
+ * ```html
+ * <sigvelo-leaflet-map>
+ *   <sigvelo-leaflet-control position="bottom-left">
+ *     <sigvelo-geo-legend title="Density" ...></sigvelo-geo-legend>
+ *   </sigvelo-leaflet-control>
+ * </sigvelo-leaflet-map>
+ * ```
+ */
+declare class SigveloLeafletControl extends LitElement {
+  /** @internal */
+  static styles: import("lit").CSSResult[];
+  /** Position of the control on the map. */
+  position: "top-left" | "top-right" | "bottom-left" | "bottom-right";
+  /** @internal */
+  private _control;
+  /** @internal */
+  private _mapEl;
+  /** @internal Map position names to Leaflet format. */
+  private _toLeafletPosition;
+  connectedCallback(): Promise<void>;
+  disconnectedCallback(): void;
+  /** @internal */
+  private _addControl;
+  render(): import("lit-html").TemplateResult<1>;
+}
+declare global {
+  interface HTMLElementTagNameMap {
+    "sigvelo-leaflet-control": SigveloLeafletControl;
+  }
+}
+//#endregion
+export { SigveloLeafletControl };

package/dist/components/control/control.js

@@ -0,0 +1,2 @@
+import { t as SigveloLeafletControl } from "../../control-ysNMOWeF.js";
+export { SigveloLeafletControl };

package/dist/components/find-leaflet-map.d.ts

@@ -0,0 +1,11 @@
+import { SigveloLeafletMap } from "./map/map.js";
+
+//#region src/components/find-leaflet-map.d.ts
+/**
+ * Finds the containing map even when a map child is rendered by a nested web
+ * component. `Element.closest()` does not cross a shadow-root boundary, while
+ * host applications may compose the reusable Leaflet elements that way.
+ */
+declare function findLeafletMap(element: HTMLElement): SigveloLeafletMap | null;
+//#endregion
+export { findLeafletMap };

package/dist/components/find-leaflet-map.js

@@ -0,0 +1,17 @@
+//#region src/components/find-leaflet-map.ts
+/**
+* Finds the containing map even when a map child is rendered by a nested web
+* component. `Element.closest()` does not cross a shadow-root boundary, while
+* host applications may compose the reusable Leaflet elements that way.
+*/
+function findLeafletMap(element) {
+	let current = element;
+	while (current) {
+		if (current instanceof HTMLElement && current.localName === "sigvelo-leaflet-map") return current;
+		const root = current.getRootNode();
+		current = current.parentNode ?? (root instanceof ShadowRoot ? root.host : null);
+	}
+	return null;
+}
+//#endregion
+export { findLeafletMap };

package/dist/components/geojson/geojson.d.ts

@@ -0,0 +1,80 @@
+import * as L from "leaflet";
+import { LitElement, PropertyValues } from "lit";
+import { GeoJsonData, StyleFunction } from "@mcp-b/geo-support/types";
+
+//#region src/components/geojson/geojson.d.ts
+/**
+ * Renders GeoJSON data on a Leaflet map. Must be a child of `<sigvelo-leaflet-map>`.
+ *
+ * @tag sigvelo-leaflet-geojson
+ *
+ * @event sigvelo-feature-click - Fired when a GeoJSON feature is clicked.
+ */
+declare class SigveloLeafletGeojson extends LitElement {
+  /** @internal */
+  static styles: import("lit").CSSResult[];
+  /** GeoJSON data (Feature or FeatureCollection). Set via property, not attribute. */
+  data: GeoJsonData | null;
+  /**
+   * Per-feature style function for choropleth / thematic maps.
+   * When set, each feature is styled by calling this function.
+   * Returned values override the static style props; omitted keys fall back to them.
+   */
+  styleFunction: StyleFunction | null;
+  /** Fill color for polygons / circles. */
+  fillColor: string;
+  /** Fill opacity (0-1). */
+  fillOpacity: number;
+  /** Stroke color. */
+  strokeColor: string;
+  /** Stroke width in pixels. */
+  strokeWidth: number;
+  /** Stroke opacity (0-1). */
+  strokeOpacity: number;
+  /** Whether features should respond to click events. */
+  interactive: boolean;
+  /** Feature property shown as the popup heading. */
+  popupTitleProperty: string;
+  /** Optional feature property shown as the popup value. */
+  popupValueProperty: string;
+  /** Optional label placed before the popup value. */
+  popupValueLabel: string;
+  /** Fit the parent map to this layer whenever it is added. */
+  fitBounds: boolean;
+  /**
+   * Channel name for auto-syncing with a classify panel.
+   * When set, styleFunction updates automatically from the panel.
+   */
+  channel: string;
+  /** @internal */
+  private _layer;
+  /** @internal */
+  private _mapEl;
+  /** @internal */
+  private _unsubscribeChannel;
+  /** Access the underlying Leaflet GeoJSON layer. */
+  get layer(): L.GeoJSON | null;
+  connectedCallback(): Promise<void>;
+  disconnectedCallback(): void;
+  /** @internal */
+  private _subscribeChannel;
+  /** @internal */
+  private _toGeoJsonFeature;
+  /** @internal */
+  private _getStyleForFeature;
+  /** @internal */
+  private _getPopupForFeature;
+  /** @internal */
+  private _addLayer;
+  /** @internal */
+  private _removeLayer;
+  protected updated(changed: PropertyValues): void;
+  render(): import("lit-html").TemplateResult<1>;
+}
+declare global {
+  interface HTMLElementTagNameMap {
+    "sigvelo-leaflet-geojson": SigveloLeafletGeojson;
+  }
+}
+//#endregion
+export { SigveloLeafletGeojson };

package/dist/components/geojson/geojson.js

@@ -0,0 +1,2 @@
+import { t as SigveloLeafletGeojson } from "../../geojson-DPaCrjMF.js";
+export { SigveloLeafletGeojson };

package/dist/components/map/map.d.ts

@@ -0,0 +1,44 @@
+import * as L from "leaflet";
+import { PropertyValues } from "lit";
+import { GeoMapElement } from "@mcp-b/geo-support/base/geo-map-element";
+import { FitBoundsOptions, FlyToOptions } from "@mcp-b/geo-support/types";
+
+//#region src/components/map/map.d.ts
+/**
+ * A Leaflet map component. Wrap tile layers, markers, and other geo elements
+ * as children of this component.
+ *
+ * @tag sigvelo-leaflet-map
+ *
+ * @event sigvelo-map-click - Fired when the map is clicked.
+ * @event sigvelo-map-move - Fired while the map center is changing.
+ * @event sigvelo-map-moveend - Fired when map movement ends.
+ * @event sigvelo-map-zoom - Fired while the zoom level is changing.
+ * @event sigvelo-map-zoomend - Fired when zooming ends.
+ * @event sigvelo-map-load - Fired when the map finishes loading.
+ */
+declare class SigveloLeafletMap extends GeoMapElement {
+  /** @internal */
+  static styles: import("lit").CSSResult[];
+  /** Whether to show default zoom controls. */
+  zoomControl: boolean;
+  /** Whether to show default attribution control. */
+  attributionControl: boolean;
+  /** @internal */
+  private _map;
+  /** Access the underlying Leaflet map instance (after mapReady resolves). */
+  get map(): L.Map | null;
+  protected createMap(container: HTMLElement): void;
+  protected destroyMap(): void;
+  protected updateView(changed: PropertyValues): void;
+  protected invalidateSize(): void;
+  flyTo(options: FlyToOptions): void;
+  fitBounds(options: FitBoundsOptions): void;
+}
+declare global {
+  interface HTMLElementTagNameMap {
+    "sigvelo-leaflet-map": SigveloLeafletMap;
+  }
+}
+//#endregion
+export { SigveloLeafletMap };

package/dist/components/map/map.js

@@ -0,0 +1,2 @@
+import { t as SigveloLeafletMap } from "../../map-DRJUOrtM.js";
+export { SigveloLeafletMap };