@edugis-org/webmapx 0.1.0

package/dist-lib/webmapx-geolocation-tool-Rw3-Iad1.js

@@ -0,0 +1,788 @@
+import { r as e, t } from "./decorate-CWgUV1hU.js";
+import { t as n } from "./webmapx-base-tool-Dm9NAWLD.js";
+import { a as r, i, o as a } from "./decorators-B35AgiCU.js";
+import "./button-DFdGkRPQ.js";
+import "./input-CeGntPlT.js";
+import "./spinner-DysxdNG9.js";
+import "./icon-button-Da_nBTy3.js";
+import { a as o, i as s, t as c } from "./zip.js-DVhmtjxZ.js";
+import { css as l, html as u } from "lit";
+//#region src/components/webmapx-geolocation-tool.ts
+var d, f = "webmapx-geolocation-tracks", p = "webmapx-geolocation-track-last-id";
+function m() {
+	try {
+		let e = localStorage.getItem(f);
+		if (!e) return [];
+		let t = JSON.parse(e);
+		return Array.isArray(t) ? t : [];
+	} catch {
+		return [];
+	}
+}
+function h(e) {
+	try {
+		localStorage.setItem(f, JSON.stringify(e));
+	} catch (e) {
+		console.warn("Failed to persist track points to localStorage", e);
+	}
+}
+function g() {
+	let e = (Number(localStorage.getItem(p)) || 0) + 1;
+	try {
+		localStorage.setItem(p, String(e));
+	} catch {}
+	return e;
+}
+function _(e) {
+	let t = [...e].sort((e, t) => e[0] - t[0] || e[1] - t[1]), n = [], r = [], i = null, a = [], o = () => {
+		i !== null && a.length >= 2 && r.push({
+			type: "Feature",
+			geometry: {
+				type: "LineString",
+				coordinates: a
+			},
+			properties: { track: i }
+		});
+	};
+	for (let [e, r, s, c, l, u] of t) n.push({
+		type: "Feature",
+		geometry: {
+			type: "Point",
+			coordinates: [c, l]
+		},
+		properties: {
+			track: e,
+			order: r,
+			timestamp: s,
+			precision: u ?? 0
+		}
+	}), e !== i && (o(), i = e, a = []), a.push([c, l]);
+	return o(), {
+		points: {
+			type: "FeatureCollection",
+			features: n
+		},
+		lines: {
+			type: "FeatureCollection",
+			features: r
+		}
+	};
+}
+function v(e, t, n, r) {
+	let i = (e) => e * Math.PI / 180, a = i(n - e), o = i(r - t), s = Math.sin(a / 2) ** 2 + Math.cos(i(e)) * Math.cos(i(n)) * Math.sin(o / 2) ** 2;
+	return 2 * 6371e3 * Math.asin(Math.sqrt(s));
+}
+function y(e, t, n) {
+	if (!e) return t;
+	let r = (t.timestamp - e.timestamp) / 1e3;
+	if (r <= 0) return null;
+	let i = v(e.lat, e.lng, t.lat, t.lng), a = i / r;
+	if (i + t.accuracy <= e.accuracy || r > Math.min(30, Math.max(1, e.accuracy / Math.max(n, 1)))) return t;
+	let o = t.accuracy / e.accuracy;
+	return o > 2.5 ? null : i <= e.accuracy + t.accuracy && o <= 1 ? t : a > Math.max(300, n * 4) ? null : t;
+}
+var b = class extends n {
+	static {
+		d = this;
+	}
+	constructor(...e) {
+		super(...e), this.toolId = "geolocation", this.watch = !0, this.highAccuracy = !0, this.timeout = 45e3, this.maxAge = 0, this.follow = !1, this.active = !1, this.status = "idle", this.message = "Determining position...", this.lastUpdate = null, this.exportDialogOpen = !1, this.storedPointCount = 0, this.exportFilenameStep = !1, this.exportFilename = "gps-tracks", this.eraseAfterExport = !0, this.mapElement = null, this.flownTo = !1, this.sourceId = "__webmapx-geolocation", this.trailLayerId = "__webmapx-geolocation-trail", this.exportLayerId = "webmapx-geolocation-tracks-export", this.exportLinesSourceId = `${this.exportLayerId}:lines`, this.exportPointsSourceId = `${this.exportLayerId}:points`, this.radiusLayerId = "__webmapx-geolocation-radius", this.pointLayerId = "__webmapx-geolocation-point", this.panelLinked = !1, this.panelElement = null, this.boundHandleToolSelect = (e) => this.handleToolSelect(e), this.boundHandleToolActivated = (e) => this.handleToolActivated(e), this.boundHandlePanelClose = () => this.handlePanelClose();
+	}
+	static {
+		this.mapStates = /* @__PURE__ */ new Map();
+	}
+	static {
+		this.globalWatchId = null;
+	}
+	static {
+		this.globalListeners = /* @__PURE__ */ new Set();
+	}
+	static {
+		this.globalLastPosition = null;
+	}
+	static {
+		this.globalLastError = null;
+	}
+	static {
+		this.wakeLock = null;
+	}
+	static {
+		this.wakeLockListenerAdded = !1;
+	}
+	static {
+		this.boundReacquireWakeLock = () => d.reacquireWakeLockIfNeeded();
+	}
+	static {
+		this.styles = l`
+    :host {
+      display: block;
+      box-sizing: border-box;
+      pointer-events: auto;
+    }
+
+    :host([hidden]) {
+      display: none !important;
+    }
+
+    .tool-content {
+      display: flex;
+      flex-direction: column;
+      gap: 0.5rem;
+      padding: 0.75rem;
+      color: var(--color-text-primary);
+    }
+
+    .title {
+      display: flex;
+      align-items: center;
+      gap: 0.4rem;
+      font-weight: 600;
+      font-size: 1rem;
+      border-bottom: 1px solid var(--color-border-light);
+      padding-bottom: 0.5rem;
+    }
+
+    .title sl-spinner {
+      font-size: 1em;
+      --track-width: 2px;
+      --indicator-color: var(--sl-color-neutral-900);
+      --track-color: var(--sl-color-neutral-300);
+    }
+
+    .status {
+      font-size: 0.875rem;
+      color: var(--color-text-secondary);
+    }
+
+    .meta {
+      font-size: 0.75rem;
+      color: var(--color-text-secondary);
+    }
+
+    .follow {
+      display: flex;
+      align-items: center;
+      gap: 0.5rem;
+      font-size: 0.875rem;
+    }
+  `;
+	}
+	connectedCallback() {
+		super.connectedCallback(), this.panelElement = this.closest("webmapx-tool-panel"), this.panelLinked = !!this.panelElement, this.panelElement?.addEventListener("webmapx-panel-close", this.boundHandlePanelClose);
+	}
+	disconnectedCallback() {
+		this.panelElement?.removeEventListener("webmapx-panel-close", this.boundHandlePanelClose), this.panelElement = null, this.panelLinked = !1, super.disconnectedCallback();
+	}
+	onMapAttached(t) {
+		this.adapter = t, this.mapElement = e(this), this.incrementSharedState(), this.panelLinked && this.mapElement && (this.mapElement.addEventListener("webmapx-tool-select", this.boundHandleToolSelect), this.mapElement.addEventListener("webmapx-tool-activated", this.boundHandleToolActivated));
+	}
+	onMapDetached() {
+		this.active && (this.hidden = !0, this.stopTracking()), this.releaseSharedState(), this.mapElement && (this.mapElement.removeEventListener("webmapx-tool-select", this.boundHandleToolSelect), this.mapElement.removeEventListener("webmapx-tool-activated", this.boundHandleToolActivated)), this.adapter = null, this.mapElement = null;
+	}
+	onStateChanged() {}
+	activate() {
+		if (this.hidden = !1, !this.active) if (this.flownTo = !1, this.lastUpdate = null, this.status = "locating", this.message = "Determining position...", this.incrementActiveState(), this.startGeolocation(), this.active = !0, d.globalLastPosition && this.mapElement) {
+			let e = d.globalLastPosition;
+			this.handleSharedPosition(e);
+			let t = this.getMapStateIfAny(this.mapElement);
+			if (t) {
+				let n = t.bestFix ?? {
+					lng: e.coords.longitude,
+					lat: e.coords.latitude,
+					accuracy: e.coords.accuracy,
+					timestamp: e.timestamp
+				};
+				t.bestFix = n, this.updateMapForPosition(n, t);
+				let r = this.mapElement.adapter;
+				r && this.maybeRecenter(n, t.listeners, r);
+			}
+		} else d.globalLastError && this.handleSharedError(d.globalLastError);
+	}
+	deactivate() {
+		this.active && (this.hidden = !0, !this.follow && this.stopTracking());
+	}
+	stopTracking() {
+		this.active &&= (this.decrementActiveState(), this.status = "idle", this.message = "Determining position...", this.lastUpdate = null, this.flownTo = !1, !1);
+	}
+	toggle() {
+		this.active ? this.deactivate() : this.activate();
+	}
+	handleToolSelect(e) {
+		if (this.panelLinked) {
+			if ((e.detail?.toolId ?? null) === this.toolId) {
+				this.activate();
+				return;
+			}
+			this.active && this.deactivate();
+		}
+	}
+	handleToolActivated(e) {
+		if (!this.panelLinked) return;
+		let t = e.detail?.toolId ?? null;
+		t && t !== this.toolId && this.active && this.deactivate();
+	}
+	handlePanelClose() {
+		this.panelLinked && this.active && this.deactivate();
+	}
+	startGeolocation() {
+		if (!navigator.geolocation) {
+			this.status = "error", this.message = "Geolocation is not available in this browser.", this.dispatchEvent(new CustomEvent("webmapx-geolocation-error", {
+				detail: { message: this.message },
+				bubbles: !0,
+				composed: !0
+			})), this.deactivate();
+			return;
+		}
+		this.ensureMapLayers(), this.dispatchEvent(new CustomEvent("webmapx-geolocation-start", {
+			detail: { watch: !0 },
+			bubbles: !0,
+			composed: !0
+		})), this.requestSingleFix(), this.updateGlobalWatchState();
+	}
+	buildOptions() {
+		return {
+			enableHighAccuracy: this.highAccuracy,
+			timeout: this.timeout,
+			maximumAge: this.maxAge
+		};
+	}
+	handleSharedPosition(e) {
+		this.status = "watching", this.updateMessage(e), this.lastUpdate = (/* @__PURE__ */ new Date()).toLocaleTimeString(), this.dispatchEvent(new CustomEvent("webmapx-geolocation-success", {
+			detail: {
+				position: e,
+				watch: !0
+			},
+			bubbles: !0,
+			composed: !0
+		}));
+	}
+	handleSharedError(e) {
+		let t = [
+			`Error: ${{
+				1: "Permission denied",
+				2: "Position unavailable",
+				3: "Timeout"
+			}[e.code] || "Unknown error"}`,
+			`Code: ${e.code}`,
+			e.message ? `Details: ${e.message}` : null
+		].filter(Boolean);
+		this.message = t.join("\n"), this.status = d.globalWatchId === null ? "error" : "watching", this.dispatchEvent(new CustomEvent("webmapx-geolocation-error", {
+			detail: { error: e },
+			bubbles: !0,
+			composed: !0
+		}));
+	}
+	requestSingleFix() {
+		navigator.geolocation.getCurrentPosition((e) => this.handleGlobalUpdate(e), (e) => this.handleGlobalErrorUpdate(e), this.buildOptions());
+	}
+	async ensureMapLayers(e, t) {
+		let n = e ?? this.adapter, r = t ?? this.mapElement;
+		if (!n || !r) return;
+		let i = this.getMapState(r), a = n.getSource(this.sourceId);
+		if (i.layersReady && a) return;
+		try {
+			a || n.addSource(this.sourceId, {
+				type: "geojson",
+				data: {
+					type: "FeatureCollection",
+					features: []
+				}
+			}), n.suppressBusySignalForSource(this.sourceId);
+		} catch {}
+		let o = !1;
+		try {
+			await r.addLayerRequest({
+				id: this.trailLayerId,
+				type: "line",
+				source: this.sourceId,
+				metadata: {
+					isToolLayer: !0,
+					hideFromLegend: !0,
+					label: "Geolocation trail"
+				},
+				paint: {
+					"line-color": "rgb(66, 133, 244)",
+					"line-width": 3,
+					"line-opacity": .8
+				},
+				filter: [
+					"==",
+					"$type",
+					"LineString"
+				]
+			}) || (o = !0);
+		} catch {
+			o = !0;
+		}
+		try {
+			await r.addLayerRequest({
+				id: this.radiusLayerId,
+				type: "fill",
+				source: this.sourceId,
+				metadata: {
+					isToolLayer: !0,
+					hideFromLegend: !0,
+					label: "Geolocation precision"
+				},
+				paint: {
+					"fill-color": "rgb(149, 201, 253)",
+					"fill-opacity": .5,
+					"fill-outline-color": "rgb(66, 133, 244)"
+				},
+				filter: [
+					"==",
+					"$type",
+					"Polygon"
+				]
+			}) || (o = !0);
+		} catch {
+			o = !0;
+		}
+		try {
+			await r.addLayerRequest({
+				id: this.pointLayerId,
+				type: "circle",
+				source: this.sourceId,
+				metadata: {
+					isToolLayer: !0,
+					hideFromLegend: !0,
+					label: "Geolocation position"
+				},
+				paint: {
+					"circle-radius": 10,
+					"circle-color": "rgb(66, 133, 244)",
+					"circle-stroke-color": "#fff",
+					"circle-stroke-width": 1
+				},
+				filter: [
+					"==",
+					"$type",
+					"Point"
+				]
+			}) || (o = !0);
+		} catch {
+			o = !0;
+		}
+		i.layersReady = !o;
+	}
+	clearMapLayers() {
+		if (!this.adapter || !this.mapElement) return;
+		let e = this.getMapStateIfAny(this.mapElement);
+		if (!(e && !e.layersReady)) {
+			try {
+				this.mapElement.removeInlineLayer(this.trailLayerId);
+			} catch {}
+			try {
+				this.mapElement.removeInlineLayer(this.radiusLayerId);
+			} catch {}
+			try {
+				this.mapElement.removeInlineLayer(this.pointLayerId);
+			} catch {}
+			try {
+				this.adapter.unsuppressBusySignalForSource(this.sourceId);
+			} catch {}
+			try {
+				this.adapter.removeSource(this.sourceId);
+			} catch {}
+			e && (e.layersReady = !1);
+		}
+	}
+	clearMapData() {
+		if (!this.adapter) return;
+		let e = this.adapter.getSource(this.sourceId);
+		e && e.setData({
+			type: "FeatureCollection",
+			features: []
+		});
+	}
+	incrementSharedState() {
+		if (!this.mapElement) return;
+		let e = this.getMapState(this.mapElement);
+		e.count += 1;
+	}
+	releaseSharedState() {
+		if (!this.mapElement) return;
+		let e = this.getMapStateIfAny(this.mapElement);
+		e && (--e.count, e.count <= 0 && d.mapStates.delete(this.mapElement));
+	}
+	getMapState(e) {
+		let t = d.mapStates.get(e);
+		return t || (t = {
+			count: 0,
+			activeCount: 0,
+			layersReady: !1,
+			listeners: /* @__PURE__ */ new Set(),
+			mapElement: e,
+			bestFix: null,
+			recentSpeed: 0,
+			trail: [],
+			currentTrackId: null,
+			trackOrder: 0
+		}, d.mapStates.set(e, t)), t;
+	}
+	getMapStateIfAny(e) {
+		return d.mapStates.get(e) ?? null;
+	}
+	incrementActiveState() {
+		if (!this.mapElement) return;
+		let e = this.getMapState(this.mapElement);
+		e.activeCount += 1, e.listeners.add(this), d.globalListeners.add(this), d.updateWakeLock();
+	}
+	decrementActiveState() {
+		if (!this.mapElement) return;
+		let e = this.getMapStateIfAny(this.mapElement);
+		e && (e.activeCount = Math.max(0, e.activeCount - 1), e.listeners.delete(this), d.globalListeners.delete(this), d.updateWakeLock(), e.activeCount === 0 && (this.clearMapData(), this.clearMapLayers(), e.bestFix = null, e.recentSpeed = 0, e.trail = []), d.globalListeners.size === 0 && (this.stopGlobalWatch(), d.globalLastPosition = null, d.globalLastError = null), this.updateGlobalWatchState());
+	}
+	startGlobalWatch() {
+		d.globalWatchId === null && (d.globalWatchId = navigator.geolocation.watchPosition((e) => this.handleGlobalUpdate(e), (e) => this.handleGlobalErrorUpdate(e), this.buildOptions()));
+	}
+	stopGlobalWatch() {
+		d.globalWatchId !== null && (navigator.geolocation.clearWatch(d.globalWatchId), d.globalWatchId = null, this.dispatchEvent(new CustomEvent("webmapx-geolocation-stop", {
+			bubbles: !0,
+			composed: !0
+		})));
+	}
+	static shouldHoldWakeLock() {
+		let e = !1;
+		return d.globalListeners.forEach((t) => {
+			t.follow && (e = !0);
+		}), e;
+	}
+	static ensureWakeLockListener() {
+		d.wakeLockListenerAdded || typeof document > "u" || (document.addEventListener("visibilitychange", d.boundReacquireWakeLock), d.wakeLockListenerAdded = !0);
+	}
+	static reacquireWakeLockIfNeeded() {
+		document.visibilityState === "visible" && d.shouldHoldWakeLock() && !d.wakeLock && d.requestWakeLock();
+	}
+	static async requestWakeLock() {
+		if (!(d.wakeLock || !("wakeLock" in navigator))) {
+			d.ensureWakeLockListener();
+			try {
+				let e = await navigator.wakeLock.request("screen");
+				e.addEventListener("release", () => {
+					d.wakeLock === e && (d.wakeLock = null);
+				}), d.wakeLock = e;
+			} catch {
+				d.wakeLock = null;
+			}
+		}
+	}
+	static releaseWakeLock() {
+		let e = d.wakeLock;
+		e && (d.wakeLock = null, e.release().catch(() => {}));
+	}
+	static updateWakeLock() {
+		d.shouldHoldWakeLock() ? d.requestWakeLock() : d.releaseWakeLock();
+	}
+	updateGlobalWatchState() {
+		if (d.globalListeners.size > 0) {
+			this.startGlobalWatch();
+			return;
+		}
+		d.globalWatchId !== null && this.stopGlobalWatch();
+	}
+	handleGlobalUpdate(e) {
+		d.globalLastPosition = e, d.globalLastError = null;
+		let t = {
+			lng: e.coords.longitude,
+			lat: e.coords.latitude,
+			accuracy: e.coords.accuracy,
+			timestamp: e.timestamp
+		};
+		d.mapStates.forEach((n) => {
+			if (n.activeCount === 0) return;
+			let r = y(n.bestFix, t, n.recentSpeed);
+			if (r) {
+				if (n.bestFix) {
+					let e = (r.timestamp - n.bestFix.timestamp) / 1e3;
+					if (e > 0) {
+						let t = v(n.bestFix.lat, n.bestFix.lng, r.lat, r.lng);
+						n.recentSpeed = n.recentSpeed * .7 + t / e * .3;
+					}
+				}
+				n.bestFix = r, d.anyFollowing(n) && (n.trail.push([r.lng, r.lat]), this.persistTrackPoint(n, r)), this.updateMapForPosition(r, n);
+				let e = n.mapElement.adapter;
+				e && this.maybeRecenter(r, n.listeners, e);
+			}
+			n.listeners.forEach((t) => t.handleSharedPosition(e));
+		});
+	}
+	persistTrackPoint(e, t) {
+		if (e.currentTrackId === null) return;
+		e.trackOrder += 1;
+		let n = m();
+		n.push([
+			e.currentTrackId,
+			e.trackOrder,
+			t.timestamp,
+			t.lng,
+			t.lat,
+			t.accuracy
+		]), h(n);
+	}
+	static anyFollowing(e) {
+		let t = !1;
+		return e.listeners.forEach((e) => {
+			e.follow && (t = !0);
+		}), t;
+	}
+	handleGlobalErrorUpdate(e) {
+		d.globalLastError = e, d.globalLastPosition = null, d.mapStates.forEach((t) => {
+			t.listeners.forEach((t) => t.handleSharedError(e));
+		});
+	}
+	maybeRecenter(e, t, n) {
+		let r = !1, i = null;
+		if (t.forEach((e) => {
+			if (e.follow || !e.flownTo) {
+				if (r = !0, !e.flownTo) {
+					let t = n.getViewportState().zoom ?? 0, r = typeof e.zoom == "number" ? e.zoom : Math.max(t, 15);
+					i = i === null ? r : Math.max(i, r);
+				}
+				e.flownTo = !0;
+			}
+		}), !r) return;
+		let a = [e.lng, e.lat], o = i ?? n.getViewportState().zoom ?? 0;
+		try {
+			n.setViewport(a, o);
+		} catch (e) {
+			console.warn("geolocation setViewport failed", e);
+		}
+	}
+	updateMapForPosition(e, t) {
+		let n = t.mapElement, r = n.adapter;
+		if (!r) return;
+		t.layersReady || this.ensureMapLayers(r, n);
+		let i = [];
+		t.trail.length >= 2 && i.push(this.createTrailFeature(t.trail)), i.push(this.createAccuracyCircle(e.lng, e.lat, e.accuracy)), i.push(this.createPoint(e.lng, e.lat));
+		let a = {
+			type: "FeatureCollection",
+			features: i
+		}, o = r.getSource(this.sourceId);
+		o && o.setData(a);
+	}
+	updateMessage(e) {
+		let t = e.coords.accuracy || 0, n = 6 - Math.round(Math.log10(Math.max(t, 1))), r = Math.max(0, Math.min(6, n));
+		this.message = `Longitude: ${e.coords.longitude.toFixed(r)}°\nLatitude: ${e.coords.latitude.toFixed(r)}°\nPrecision: ${Math.round(t)} m`;
+	}
+	handleFollowChange(e) {
+		let t = e.target;
+		if (t) {
+			if (this.follow = t.checked, this.follow && this.mapElement) {
+				let e = this.getMapStateIfAny(this.mapElement);
+				e && (e.trail = [], e.currentTrackId = g(), e.trackOrder = 0, e.bestFix && (e.trail.push([e.bestFix.lng, e.bestFix.lat]), this.persistTrackPoint(e, e.bestFix)));
+			} else if (!this.follow && this.mapElement) {
+				let e = this.getMapStateIfAny(this.mapElement);
+				e && (e.currentTrackId = null);
+			}
+			d.updateWakeLock();
+		}
+	}
+	formatStatus() {
+		switch (this.status) {
+			case "locating": return "Locating";
+			case "watching": return "Watching";
+			case "success": return "Active";
+			case "error": return "Error";
+			default: return "Idle";
+		}
+	}
+	createAccuracyCircle(e, t, n) {
+		let r = n / 1e3, i = r / (111.32 * Math.cos(t * Math.PI / 180)), a = r / 110.574, o = [];
+		for (let n = 0; n < 64; n += 1) {
+			let r = n / 64 * (2 * Math.PI), s = i * Math.cos(r), c = a * Math.sin(r);
+			o.push([e + s, t + c]);
+		}
+		return o.push(o[0]), {
+			type: "Feature",
+			geometry: {
+				type: "Polygon",
+				coordinates: [o]
+			},
+			properties: {}
+		};
+	}
+	createPoint(e, t) {
+		return {
+			type: "Feature",
+			geometry: {
+				type: "Point",
+				coordinates: [e, t]
+			},
+			properties: {}
+		};
+	}
+	createTrailFeature(e) {
+		return {
+			type: "Feature",
+			geometry: {
+				type: "LineString",
+				coordinates: e
+			},
+			properties: {}
+		};
+	}
+	render() {
+		return u`
+      <div class="tool-content">
+        <div class="title">
+          Location
+          ${this.status === "locating" ? u`<sl-spinner></sl-spinner>` : ""}
+          <sl-icon-button
+            name="box-arrow-up"
+            label="Export tracked points"
+            title="Export tracked points"
+            style="margin-left: auto;"
+            @click=${() => {
+			this.storedPointCount = m().length, this.exportDialogOpen = !0;
+		}}
+          ></sl-icon-button>
+        </div>
+        <div class="status" style="white-space: pre-line;">${this.message}</div>
+        <div class="follow">
+          <label>
+            <input type="checkbox" .checked=${this.follow} @change=${this.handleFollowChange} />
+            Track me
+          </label>
+        </div>
+        <div class="meta">
+          Status: ${this.formatStatus()}${this.lastUpdate ? ` | Updated: ${this.lastUpdate}` : ""}
+        </div>
+      </div>
+
+      <sl-dialog label="Export tracked points" .open=${this.exportDialogOpen}
+        @sl-request-close=${() => {
+			this.exportDialogOpen = !1, this.exportFilenameStep = !1;
+		}}>
+        ${this.exportFilenameStep ? u`
+          <div style="display:flex; align-items:center; gap:0.4rem;">
+            <span>Filename</span>
+            <sl-input style="flex:1;" size="small" .value=${this.exportFilename} aria-label="Export filename"
+              @sl-input=${(e) => {
+			this.exportFilename = e.target.value;
+		}}>
+              <span slot="suffix">.zip</span>
+            </sl-input>
+          </div>
+          <div slot="footer" style="display:flex; gap:0.5rem; flex-wrap:wrap;">
+            <sl-button variant="primary" autofocus @click=${() => this.handleExportSaveFiles()}>Download</sl-button>
+            <sl-button variant="text" @click=${() => {
+			this.exportFilenameStep = !1;
+		}}>Back</sl-button>
+          </div>
+        ` : u`
+          <p>Save the recorded GPS tracks as GeoJSON, or add them to the map.</p>
+          <p>${this.storedPointCount} point(s) stored.</p>
+          <label style="display:flex; align-items:center; gap:0.4rem; margin-bottom:0.5rem;">
+            <input type="checkbox" .checked=${this.eraseAfterExport}
+              @change=${(e) => {
+			this.eraseAfterExport = e.target.checked;
+		}} />
+            <span>Erase from memory</span>
+          </label>
+          <div slot="footer" style="display:flex; gap:0.5rem; flex-wrap:wrap;">
+            <sl-button autofocus .disabled=${this.storedPointCount === 0} @click=${() => this.openExportFilenameStep()}>Save as files</sl-button>
+            <sl-button .disabled=${this.storedPointCount === 0} @click=${() => this.handleExportAddToMap()}>Add to map</sl-button>
+            <sl-button variant="text" @click=${() => {
+			this.exportDialogOpen = !1;
+		}}>Cancel</sl-button>
+          </div>
+        `}
+      </sl-dialog>
+    `;
+	}
+	openExportFilenameStep() {
+		let e = /* @__PURE__ */ new Date(), t = (/* @__PURE__ */ new Date(e.getTime() - e.getTimezoneOffset() * 6e4)).toISOString().slice(0, 16).replace(":", "");
+		this.exportFilename = `gps-tracks-${t}`, this.exportFilenameStep = !0;
+	}
+	async handleExportSaveFiles() {
+		let { points: e, lines: t } = _(m()), n = this.exportFilename.trim() || "gps-tracks", r = new c(new s("application/zip"));
+		await r.add("gps-track-points.geojson", new o(JSON.stringify(e, null, 2))), await r.add("gps-track-lines.geojson", new o(JSON.stringify(t, null, 2)));
+		let i = this.buildTracksStyleConfig("gps-track-lines.geojson", "gps-track-points.geojson");
+		await r.add("style.json", new o(JSON.stringify(i, null, 2))), this.downloadBlob(await r.close(), `${n}.zip`), this.eraseAfterExport && this.eraseStoredTracks(), this.exportFilenameStep = !1, this.exportDialogOpen = !1;
+	}
+	buildTracksStyleConfig(e, t) {
+		return {
+			id: this.exportLayerId,
+			type: "style",
+			version: 8,
+			metadata: {
+				label: "GPS tracks",
+				legendRole: "overlay",
+				abstract: "Tracked GPS points and the tracks connecting them, recorded via \"Track me\".",
+				properties: [{
+					name: "timestamp",
+					type: "create-time"
+				}]
+			},
+			sources: {
+				lines: {
+					type: "geojson",
+					data: e
+				},
+				points: {
+					type: "geojson",
+					data: t
+				}
+			},
+			layers: [{
+				id: "gps-tracks-lines",
+				type: "line",
+				source: "lines",
+				metadata: { label: "GPS tracks" },
+				paint: {
+					"line-color": "rgb(66, 133, 244)",
+					"line-width": 3,
+					"line-opacity": .8
+				}
+			}, {
+				id: "gps-tracks-points",
+				type: "circle",
+				source: "points",
+				metadata: { label: "GPS points" },
+				paint: {
+					"circle-radius": 3,
+					"circle-color": "#ffffff",
+					"circle-stroke-color": "rgb(66, 133, 244)",
+					"circle-stroke-width": 1
+				}
+			}]
+		};
+	}
+	eraseStoredTracks() {
+		if (h([]), this.storedPointCount = 0, this.mapElement) {
+			let e = this.getMapStateIfAny(this.mapElement);
+			e && (e.trail = [], e.trackOrder = 0);
+		}
+	}
+	async handleExportAddToMap() {
+		if (this.exportDialogOpen = !1, !this.adapter || !this.mapElement) return;
+		let e = this.adapter, { points: t, lines: n } = _(m());
+		t.features.length !== 0 && (e.hasLayer(this.exportLayerId) ? (e.getSource(this.exportLinesSourceId)?.setData(n), e.getSource(this.exportPointsSourceId)?.setData(t)) : await this.mapElement.addLayerRequest(this.buildTracksStyleConfig(n, t)), this.eraseAfterExport && this.eraseStoredTracks());
+	}
+	downloadBlob(e, t) {
+		let n = URL.createObjectURL(e), r = document.createElement("a");
+		r.href = n, r.download = t, r.click(), URL.revokeObjectURL(n);
+	}
+};
+t([r({
+	type: Boolean,
+	attribute: "watch"
+})], b.prototype, "watch", void 0), t([r({
+	type: Boolean,
+	attribute: "high-accuracy"
+})], b.prototype, "highAccuracy", void 0), t([r({
+	type: Number,
+	attribute: "timeout"
+})], b.prototype, "timeout", void 0), t([r({
+	type: Number,
+	attribute: "max-age"
+})], b.prototype, "maxAge", void 0), t([r({ type: Number })], b.prototype, "zoom", void 0), t([r({
+	type: Boolean,
+	attribute: "follow"
+})], b.prototype, "follow", void 0), t([r({
+	type: Boolean,
+	reflect: !0
+})], b.prototype, "active", void 0), t([i()], b.prototype, "status", void 0), t([i()], b.prototype, "message", void 0), t([i()], b.prototype, "lastUpdate", void 0), t([i()], b.prototype, "exportDialogOpen", void 0), t([i()], b.prototype, "storedPointCount", void 0), t([i()], b.prototype, "exportFilenameStep", void 0), t([i()], b.prototype, "exportFilename", void 0), t([i()], b.prototype, "eraseAfterExport", void 0), b = d = t([a("webmapx-geolocation-tool")], b);
+//#endregion
+export { b as WebmapxGeolocationTool, y as evaluateGeolocationFix };