npm - @datum-cloud/datum-ui - Versions diffs - 0.2.0-alpha.3 → 0.2.0-alpha.4 - Mend

@datum-cloud/datum-ui 0.2.0-alpha.3 → 0.2.0-alpha.4

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (132) hide show

package/README.md +46 -21
package/dist/alert/index.mjs +3 -0
package/dist/alert-BC2Mccfo.mjs +95 -0
package/dist/autocomplete/index.mjs +7 -0
package/dist/autocomplete-DZtI97HP.mjs +295 -0
package/dist/avatar-stack/index.mjs +5 -0
package/dist/avatar-stack-JCfBlPB9.mjs +80 -0
package/dist/badge/index.mjs +3 -0
package/dist/badge-bFgeYceE.mjs +185 -0
package/dist/breadcrumb/index.mjs +4 -0
package/dist/breadcrumb-BGYJgom_.mjs +71 -0
package/dist/button/index.mjs +4 -0
package/dist/button-AzpnV-WB.mjs +49 -0
package/dist/button-C1wRfGtT.mjs +230 -0
package/dist/button-group/index.mjs +5 -0
package/dist/button-group-C1IB2K5s.mjs +40 -0
package/dist/calendar/index.mjs +5 -0
package/dist/calendar-DlIHeWb0.mjs +113 -0
package/dist/card/index.mjs +4 -0
package/dist/card-3Kd0VdNf.mjs +63 -0
package/dist/chart/index.mjs +4 -0
package/dist/chart-BZqUKpkh.mjs +143 -0
package/dist/checkbox/index.mjs +4 -0
package/dist/checkbox-LG1OKTpG.mjs +34 -0
package/dist/col-lrLMZaTJ.mjs +184 -0
package/dist/collapsible/index.mjs +3 -0
package/dist/collapsible-Bt9UYfv3.mjs +9 -0
package/dist/command/index.mjs +5 -0
package/dist/command-s0Yv3abE.mjs +86 -0
package/dist/components/features/date-picker/index.d.ts +3 -0
package/dist/components/features/date-picker/index.d.ts.map +1 -0
package/dist/components/features/dropzone/index.d.ts +1 -0
package/dist/components/features/dropzone/index.d.ts.map +1 -1
package/dist/date-picker/index.mjs +9 -0
package/dist/{datum.provider-D6VMjSV0.mjs → datum.provider-B77goJgl.mjs} +1 -1
package/dist/dialog/index.mjs +5 -0
package/dist/dialog-DXBaT9gA.mjs +86 -0
package/dist/dialog-bnMMf9GD.mjs +73 -0
package/dist/dropdown/index.mjs +3 -0
package/dist/dropdown-DtSa_lqc.mjs +112 -0
package/dist/dropzone/index.mjs +5 -0
package/dist/dropzone-BkOnwrS4.mjs +221 -0
package/dist/empty-content/index.mjs +3 -0
package/dist/empty-content-BM9rzI13.mjs +196 -0
package/dist/exports/map.d.ts +3 -0
package/dist/exports/map.d.ts.map +1 -0
package/dist/form/index.mjs +146 -0
package/dist/grid/index.mjs +3 -0
package/dist/hooks/index.mjs +2 -3
package/dist/hover-card/index.mjs +4 -0
package/dist/hover-card-CUPfFUqE.mjs +33 -0
package/dist/icon-wrapper-9ticVbRL.mjs +14 -0
package/dist/icons/index.mjs +3 -3
package/dist/index.mjs +66 -8
package/dist/input/index.mjs +5 -0
package/dist/input-DuyjEKEW.mjs +17 -0
package/dist/input-fzXBheCN.mjs +17 -0
package/dist/input-group/index.mjs +7 -0
package/dist/input-group-CPaFSTEV.mjs +80 -0
package/dist/input-number/index.mjs +6 -0
package/dist/input-number-9o62JHRl.mjs +106 -0
package/dist/input-with-addons/index.mjs +3 -0
package/dist/input-with-addons-BQn7KCTU.mjs +30 -0
package/dist/label/index.mjs +4 -0
package/dist/label-_ste_Re3.mjs +44 -0
package/dist/link-button-TIF2Zdrk.mjs +36 -0
package/dist/loader-overlay/index.mjs +3 -0
package/dist/loader-overlay-DUaQSZQP.mjs +17 -0
package/dist/map/index.mjs +13 -0
package/dist/map-Df8QMcX0.mjs +1094 -0
package/dist/more-actions/index.mjs +5 -0
package/dist/more-actions-Ch1f6Mh3.mjs +54 -0
package/dist/nprogress/index.mjs +32 -0
package/dist/page-title/index.mjs +3 -0
package/dist/page-title-BJuo81rT.mjs +26 -0
package/dist/popover/index.mjs +4 -0
package/dist/popover-SQlKSz6L.mjs +36 -0
package/dist/provider/index.mjs +4 -0
package/dist/radio-group/index.mjs +4 -0
package/dist/radio-group-Oshv0b-U.mjs +49 -0
package/dist/select/index.mjs +4 -0
package/dist/select-DVlEzD2W.mjs +166 -0
package/dist/separator/index.mjs +4 -0
package/dist/separator-T2ppyD-8.mjs +18 -0
package/dist/sheet/index.mjs +5 -0
package/dist/sheet-BKiCwtNO.mjs +45 -0
package/dist/sheet-CtnP6gTD.mjs +77 -0
package/dist/sidebar/index.mjs +11 -0
package/dist/sidebar-DfqezV8t.mjs +945 -0
package/dist/skeleton/index.mjs +4 -0
package/dist/skeleton-vzbxA-DQ.mjs +13 -0
package/dist/spinner/index.mjs +4 -0
package/dist/spinner-BE7k2bAD.mjs +16 -0
package/dist/{icon-wrapper-BgPkifId.mjs → spinner.icon-Bg8zgGh0.mjs} +1 -12
package/dist/stepper/index.mjs +5 -0
package/dist/stepper-SWB-u_nM.mjs +323 -0
package/dist/switch/index.mjs +4 -0
package/dist/switch-Calk7Gyw.mjs +32 -0
package/dist/table/index.mjs +4 -0
package/dist/table-CsXBcQLI.mjs +68 -0
package/dist/tabs/index.mjs +3 -0
package/dist/tabs-D8n-dqnw.mjs +52 -0
package/dist/tag-input/index.mjs +5 -0
package/dist/tag-input-Di7SDNbK.mjs +284 -0
package/dist/task-queue/index.mjs +7 -0
package/dist/task-queue-dropdown-DW72ikDH.mjs +1356 -0
package/dist/textarea/index.mjs +5 -0
package/dist/textarea-CxE3YbC7.mjs +17 -0
package/dist/textarea-QYRcDEpK.mjs +15 -0
package/dist/theme/index.mjs +4 -0
package/dist/theme-script-XBouzsNR.mjs +66 -0
package/dist/to-api-format-C2xjQUcI.mjs +1506 -0
package/dist/toast/index.mjs +3 -0
package/dist/tooltip/index.mjs +4 -0
package/dist/tooltip-Dd3ActSS.mjs +74 -0
package/dist/typography/index.mjs +3 -0
package/dist/typography-UA7ZZvgJ.mjs +200 -0
package/dist/use-copy-to-clipboard-ki-WoTml.mjs +31 -0
package/dist/use-stepper-BaToCYMs.mjs +2017 -0
package/dist/{use-copy-to-clipboard-BfrpD6G8.mjs → use-toast-mdn_CqRY.mjs} +34 -27
package/dist/utils/index.mjs +0 -1
package/dist/utils-Bfgoe-Gm.mjs +20 -0
package/dist/visually-hidden/index.mjs +3 -0
package/dist/visuallyhidden-aaTUk4Yo.mjs +7 -0
package/package.json +208 -8
package/dist/components/index.mjs +0 -8
package/dist/providers/index.mjs +0 -4
package/dist/theme-script-DHyLk25i.mjs +0 -11128
/package/dist/{close.icon-chkXPAUC.mjs → close.icon-CMNMoXM_.mjs} +0 -0
/package/dist/{map-leaflet-imports-OKaoesjZ.mjs → map-leaflet-imports-CdzvEnzY.mjs} +0 -0
/package/dist/{theme.provider-DpFLwtHe.mjs → theme.provider-DgGshapa.mjs} +0 -0
/package/dist/{use-debounce-BYB-jPeX.mjs → use-debounce-DQ1tmxOL.mjs} +0 -0

package/dist/map-Df8QMcX0.mjs ADDED Viewed

@@ -0,0 +1,1094 @@
+import { t as cn } from "./utils-Bfgoe-Gm.mjs";
+import { t as ButtonGroup } from "./button-group-C1IB2K5s.mjs";
+import { t as Button } from "./button-AzpnV-WB.mjs";
+import { i as CommandGroup, o as CommandItem, r as CommandEmpty, s as CommandList, t as Command } from "./command-s0Yv3abE.mjs";
+import { i as InputGroupInput, n as InputGroupAddon, t as InputGroup } from "./input-group-CPaFSTEV.mjs";
+import { t as Spinner } from "./spinner-BE7k2bAD.mjs";
+import { CheckIcon, ChevronRightIcon, CircleIcon, LayersIcon, LoaderCircleIcon, MapPinIcon, MaximizeIcon, MinimizeIcon, MinusIcon, NavigationIcon, PenLineIcon, PentagonIcon, PlusIcon, SearchIcon, SquareIcon, Trash2Icon, Undo2Icon, WaypointsIcon } from "lucide-react";
+import * as React$1 from "react";
+import React, { Suspense, createContext, lazy, useContext, useEffect, useRef, useState } from "react";
+import { Fragment as Fragment$1, jsx, jsxs } from "react/jsx-runtime";
+import * as DropdownMenuPrimitive from "@radix-ui/react-dropdown-menu";
+import { renderToString } from "react-dom/server.browser";
+//#region ../shadcn/hooks/use-theme.ts
+/**
+* Lightweight theme detection hook for shadcn components.
+* Detects dark mode via the `dark` class on <html> (Tailwind convention)
+* or falls back to prefers-color-scheme media query.
+*/
+function useTheme() {
+	const [resolvedTheme, setResolvedTheme] = React$1.useState("light");
+	React$1.useEffect(() => {
+		const detect = () => {
+			if (document.documentElement.classList.contains("dark")) return "dark";
+			if (window.matchMedia("(prefers-color-scheme: dark)").matches) return "dark";
+			return "light";
+		};
+		setResolvedTheme(detect());
+		const observer = new MutationObserver(() => setResolvedTheme(detect()));
+		observer.observe(document.documentElement, {
+			attributes: true,
+			attributeFilter: ["class"]
+		});
+		const mql = window.matchMedia("(prefers-color-scheme: dark)");
+		const onChange = () => setResolvedTheme(detect());
+		mql.addEventListener("change", onChange);
+		return () => {
+			observer.disconnect();
+			mql.removeEventListener("change", onChange);
+		};
+	}, []);
+	return { resolvedTheme };
+}
+//#endregion
+//#region ../shadcn/ui/dropdown-menu.tsx
+/**
+* Vanilla shadcn/ui DropdownMenu Component
+* Pure shadcn dropdown without Datum customizations
+* For Datum-specific features (destructive MenuItem), import from @/modules/datum-ui
+*/
+const DropdownMenu = DropdownMenuPrimitive.Root;
+const DropdownMenuTrigger = DropdownMenuPrimitive.Trigger;
+const DropdownMenuGroup = DropdownMenuPrimitive.Group;
+const DropdownMenuPortal = DropdownMenuPrimitive.Portal;
+const DropdownMenuSub = DropdownMenuPrimitive.Sub;
+const DropdownMenuRadioGroup = DropdownMenuPrimitive.RadioGroup;
+const DropdownMenuSubTrigger = React$1.forwardRef(({ className, inset, children, ...props }, ref) => /* @__PURE__ */ jsxs(DropdownMenuPrimitive.SubTrigger, {
+	ref,
+	className: cn("focus:bg-accent data-[state=open]:bg-accent flex cursor-default items-center gap-2 rounded-sm px-2 py-1.5 text-sm outline-none select-none [&_svg]:pointer-events-none [&_svg]:size-4 [&_svg]:shrink-0", inset && "pl-8", className),
+	...props,
+	children: [children, /* @__PURE__ */ jsx(ChevronRightIcon, { className: "ml-auto" })]
+}));
+DropdownMenuSubTrigger.displayName = DropdownMenuPrimitive.SubTrigger.displayName;
+const DropdownMenuSubContent = React$1.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx(DropdownMenuPrimitive.SubContent, {
+	ref,
+	className: cn("bg-popover text-popover-foreground data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 z-50 min-w-[8rem] overflow-hidden rounded-md border p-1 shadow-lg", className),
+	...props
+}));
+DropdownMenuSubContent.displayName = DropdownMenuPrimitive.SubContent.displayName;
+const DropdownMenuContent = React$1.forwardRef(({ className, sideOffset = 4, ...props }, ref) => /* @__PURE__ */ jsx(DropdownMenuPrimitive.Portal, { children: /* @__PURE__ */ jsx(DropdownMenuPrimitive.Content, {
+	ref,
+	sideOffset,
+	className: cn("bg-popover text-popover-foreground data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 z-50 min-w-[8rem] overflow-hidden rounded-md border p-1 shadow-md", className),
+	...props
+}) }));
+DropdownMenuContent.displayName = DropdownMenuPrimitive.Content.displayName;
+const DropdownMenuItem = React$1.forwardRef(({ className, inset, ...props }, ref) => /* @__PURE__ */ jsx(DropdownMenuPrimitive.Item, {
+	ref,
+	className: cn("focus:bg-accent focus:text-accent-foreground relative flex cursor-default items-center gap-2 rounded-sm px-2 py-1.5 text-sm transition-colors outline-none select-none data-[disabled]:pointer-events-none data-[disabled]:opacity-50 [&_svg]:pointer-events-none [&_svg]:size-4 [&_svg]:shrink-0", inset && "pl-8", className),
+	...props
+}));
+DropdownMenuItem.displayName = DropdownMenuPrimitive.Item.displayName;
+const DropdownMenuCheckboxItem = React$1.forwardRef(({ className, children, checked, ...props }, ref) => /* @__PURE__ */ jsxs(DropdownMenuPrimitive.CheckboxItem, {
+	ref,
+	className: cn("focus:bg-accent focus:text-accent-foreground relative flex cursor-default items-center rounded-sm py-1.5 pr-2 pl-8 text-sm transition-colors outline-none select-none data-[disabled]:pointer-events-none data-[disabled]:opacity-50", className),
+	checked,
+	...props,
+	children: [/* @__PURE__ */ jsx("span", {
+		className: "absolute left-2 flex h-3.5 w-3.5 items-center justify-center",
+		children: /* @__PURE__ */ jsx(DropdownMenuPrimitive.ItemIndicator, { children: /* @__PURE__ */ jsx(CheckIcon, { className: "h-4 w-4" }) })
+	}), children]
+}));
+DropdownMenuCheckboxItem.displayName = DropdownMenuPrimitive.CheckboxItem.displayName;
+const DropdownMenuRadioItem = React$1.forwardRef(({ className, children, ...props }, ref) => /* @__PURE__ */ jsxs(DropdownMenuPrimitive.RadioItem, {
+	ref,
+	className: cn("focus:bg-accent focus:text-accent-foreground relative flex cursor-default items-center rounded-sm py-1.5 pr-2 pl-8 text-sm transition-colors outline-none select-none data-[disabled]:pointer-events-none data-[disabled]:opacity-50", className),
+	...props,
+	children: [/* @__PURE__ */ jsx("span", {
+		className: "absolute left-2 flex h-3.5 w-3.5 items-center justify-center",
+		children: /* @__PURE__ */ jsx(DropdownMenuPrimitive.ItemIndicator, { children: /* @__PURE__ */ jsx(CircleIcon, { className: "h-2 w-2 fill-current" }) })
+	}), children]
+}));
+DropdownMenuRadioItem.displayName = DropdownMenuPrimitive.RadioItem.displayName;
+const DropdownMenuLabel = React$1.forwardRef(({ className, inset, ...props }, ref) => /* @__PURE__ */ jsx(DropdownMenuPrimitive.Label, {
+	ref,
+	className: cn("px-2 py-1.5 text-sm font-semibold", inset && "pl-8", className),
+	...props
+}));
+DropdownMenuLabel.displayName = DropdownMenuPrimitive.Label.displayName;
+const DropdownMenuSeparator = React$1.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx(DropdownMenuPrimitive.Separator, {
+	ref,
+	className: cn("bg-muted -mx-1 my-1 h-px", className),
+	...props
+}));
+DropdownMenuSeparator.displayName = DropdownMenuPrimitive.Separator.displayName;
+const DropdownMenuShortcut = ({ className, ...props }) => {
+	return /* @__PURE__ */ jsx("span", {
+		className: cn("ml-auto text-xs tracking-widest opacity-60", className),
+		...props
+	});
+};
+DropdownMenuShortcut.displayName = "DropdownMenuShortcut";
+//#endregion
+//#region ../shadcn/ui/place-autocomplete.tsx
+function formatAddress(properties) {
+	const parts = [];
+	if (properties.name) parts.push(properties.name);
+	if (properties.housenumber && properties.street) parts.push(`${properties.housenumber} ${properties.street}`);
+	else if (properties.street) parts.push(properties.street);
+	if (properties.city) parts.push(properties.city);
+	else if (properties.locality) parts.push(properties.locality);
+	if (properties.state && properties.state !== properties.city) parts.push(properties.state);
+	if (properties.country) parts.push(properties.country);
+	return [...new Set(parts)].join(", ");
+}
+function buildSearchUrl({ query, bbox, lang, lat, limit, locationBiasScale, lon, zoom }) {
+	const url = new URL("https://photon.komoot.io/api");
+	url.searchParams.set("q", query);
+	if (lang) url.searchParams.set("lang", lang);
+	if (limit) url.searchParams.set("limit", String(limit));
+	if (bbox) url.searchParams.set("bbox", bbox.join(","));
+	if (lat !== void 0 && lon !== void 0) {
+		url.searchParams.set("lat", String(lat));
+		url.searchParams.set("lon", String(lon));
+	}
+	if (zoom !== void 0) url.searchParams.set("zoom", String(zoom));
+	if (locationBiasScale !== void 0) url.searchParams.set("location_bias_scale", String(locationBiasScale));
+	return String(url);
+}
+function useDebounce(value, delay = 300) {
+	const [debouncedValue, setDebouncedValue] = React$1.useState(value);
+	React$1.useEffect(() => {
+		const timer = setTimeout(() => setDebouncedValue(value), delay);
+		return () => clearTimeout(timer);
+	}, [value, delay]);
+	return debouncedValue;
+}
+function usePlaceSearch({ debounceMs, query, ...props }) {
+	const [results, setResults] = React$1.useState([]);
+	const [isLoading, setIsLoading] = React$1.useState(false);
+	const [error, setError] = React$1.useState(null);
+	const [hasSearched, setHasSearched] = React$1.useState(false);
+	const debouncedQuery = useDebounce(query, debounceMs);
+	React$1.useEffect(() => {
+		if (!debouncedQuery.trim()) {
+			setResults([]);
+			setIsLoading(false);
+			setHasSearched(false);
+			return;
+		}
+		const abortController = new AbortController();
+		async function fetchResults() {
+			setIsLoading(true);
+			setError(null);
+			setHasSearched(true);
+			try {
+				const url = buildSearchUrl({
+					query: debouncedQuery,
+					...props
+				});
+				const response = await fetch(url, { signal: abortController.signal });
+				if (!response.ok) throw new Error(`Photon API error: ${response.status} ${response.statusText}`);
+				const data = await response.json();
+				const addressOsmIds = /* @__PURE__ */ new Set();
+				setResults(data.features.filter((feature) => {
+					const id = feature.properties.osm_id;
+					if (addressOsmIds.has(id)) return false;
+					addressOsmIds.add(id);
+					return true;
+				}));
+			} catch (err) {
+				if (err instanceof Error && err.name !== "AbortError") {
+					setError(err);
+					setResults([]);
+				}
+			} finally {
+				setIsLoading(false);
+			}
+		}
+		fetchResults();
+		return () => abortController.abort();
+	}, [
+		debouncedQuery,
+		props.lang,
+		props.limit,
+		props.bbox,
+		props.lat,
+		props.lon,
+		props.zoom,
+		props.locationBiasScale
+	]);
+	return {
+		results,
+		isLoading,
+		error,
+		hasSearched
+	};
+}
+function PlaceAutocomplete({ debounceMs = 300, lang, limit = 5, bbox, lat, lon, zoom, locationBiasScale, className, value: controlledValue, defaultValue = "", onChange: controlledOnChange, onPlaceSelect, onResultsChange, ...props }) {
+	const [internalValue, setInternalValue] = React$1.useState(defaultValue);
+	const [searchQuery, setSearchQuery] = React$1.useState("");
+	const isControlled = controlledValue !== void 0;
+	const displayValue = isControlled ? controlledValue : internalValue;
+	const { results, isLoading, error, hasSearched } = usePlaceSearch({
+		query: searchQuery,
+		debounceMs,
+		lang,
+		limit,
+		bbox,
+		lat,
+		lon,
+		zoom,
+		locationBiasScale
+	});
+	React$1.useEffect(() => {
+		onResultsChange?.(results);
+	}, [results, onResultsChange]);
+	const hasNoResults = hasSearched && !isLoading && !error && results.length === 0;
+	const showCommandList = error || hasNoResults || results.length > 0;
+	return /* @__PURE__ */ jsx(Command, {
+		className: cn("h-fit overflow-visible", className),
+		shouldFilter: false,
+		loop: true,
+		children: /* @__PURE__ */ jsxs("div", {
+			className: "relative",
+			children: [/* @__PURE__ */ jsxs(InputGroup, {
+				className: cn("border-input! bg-popover! ring-0!", showCommandList && "rounded-b-none"),
+				children: [
+					/* @__PURE__ */ jsx(InputGroupAddon, { children: /* @__PURE__ */ jsx(SearchIcon, {}) }),
+					/* @__PURE__ */ jsx(InputGroupInput, {
+						placeholder: "Search",
+						value: displayValue,
+						onChange: (event) => {
+							const newValue = event.target.value;
+							if (!isControlled) setInternalValue(newValue);
+							setSearchQuery(newValue);
+							controlledOnChange?.(newValue);
+						},
+						...props
+					}),
+					isLoading && /* @__PURE__ */ jsx(InputGroupAddon, {
+						align: "inline-end",
+						children: /* @__PURE__ */ jsx(Spinner, {})
+					})
+				]
+			}), showCommandList && /* @__PURE__ */ jsxs(CommandList, {
+				"data-state": showCommandList ? "open" : "closed",
+				className: cn("bg-popover border-input absolute top-full right-0 left-0 rounded-b-md border border-t-0 shadow-md", "data-[state=open]:animate-in data-[state=closed]:animate-out", "data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0", "data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95", "data-[state=open]:slide-in-from-top-2 data-[state=closed]:slide-out-to-top-2"),
+				children: [
+					error && /* @__PURE__ */ jsxs(CommandEmpty, { children: ["Error: ", error.message] }),
+					hasNoResults && /* @__PURE__ */ jsxs(CommandEmpty, { children: [
+						"Can't find ",
+						displayValue,
+						"."
+					] }),
+					results.length > 0 && /* @__PURE__ */ jsx(CommandGroup, { children: results.map((feature) => {
+						const formattedAddress = formatAddress(feature.properties);
+						return /* @__PURE__ */ jsxs(CommandItem, {
+							value: String(feature.properties.osm_id),
+							onSelect: () => {
+								const formattedAddress = formatAddress(feature.properties);
+								if (!isControlled) setInternalValue(formattedAddress);
+								setSearchQuery("");
+								controlledOnChange?.(formattedAddress);
+								onPlaceSelect?.(feature);
+							},
+							children: [/* @__PURE__ */ jsx(MapPinIcon, {}), /* @__PURE__ */ jsxs("div", {
+								className: "flex flex-col items-start text-start",
+								children: [/* @__PURE__ */ jsx("span", {
+									className: "font-medium",
+									children: feature.properties.name || feature.properties.street || "Unknown"
+								}), /* @__PURE__ */ jsx("span", {
+									className: "text-muted-foreground text-xs",
+									children: formattedAddress
+								})]
+							})]
+						}, feature.properties.osm_id);
+					}) })
+				]
+			})]
+		})
+	});
+}
+//#endregion
+//#region ../shadcn/ui/map.tsx
+let _useMap;
+let _useMapEvents;
+if (typeof window !== "undefined") import("./map-leaflet-imports-CdzvEnzY.mjs").then((mod) => {
+	_useMap = mod.useMap;
+	_useMapEvents = mod.useMapEvents;
+});
+function createLazyComponent(factory) {
+	const LazyComponent = lazy(factory);
+	return (props) => {
+		const [isMounted, setIsMounted] = useState(false);
+		useEffect(() => {
+			setIsMounted(true);
+		}, []);
+		if (!isMounted) return null;
+		return /* @__PURE__ */ jsx(Suspense, { children: /* @__PURE__ */ jsx(LazyComponent, { ...props }) });
+	};
+}
+const LeafletMapContainer = createLazyComponent(() => import("react-leaflet").then((mod) => ({ default: mod.MapContainer })));
+const LeafletTileLayer = createLazyComponent(() => import("react-leaflet").then((mod) => ({ default: mod.TileLayer })));
+const LeafletMarker = createLazyComponent(() => import("react-leaflet").then((mod) => ({ default: mod.Marker })));
+const LeafletPopup = createLazyComponent(() => import("react-leaflet").then((mod) => ({ default: mod.Popup })));
+const LeafletTooltip = createLazyComponent(() => import("react-leaflet").then((mod) => ({ default: mod.Tooltip })));
+const LeafletCircle = createLazyComponent(() => import("react-leaflet").then((mod) => ({ default: mod.Circle })));
+const LeafletCircleMarker = createLazyComponent(() => import("react-leaflet").then((mod) => ({ default: mod.CircleMarker })));
+const LeafletPolyline = createLazyComponent(() => import("react-leaflet").then((mod) => ({ default: mod.Polyline })));
+const LeafletPolygon = createLazyComponent(() => import("react-leaflet").then((mod) => ({ default: mod.Polygon })));
+const LeafletRectangle = createLazyComponent(() => import("react-leaflet").then((mod) => ({ default: mod.Rectangle })));
+const LeafletLayerGroup = createLazyComponent(() => import("react-leaflet").then((mod) => ({ default: mod.LayerGroup })));
+const LeafletFeatureGroup = createLazyComponent(() => import("react-leaflet").then((mod) => ({ default: mod.FeatureGroup })));
+const LeafletMarkerClusterGroup = createLazyComponent(async () => import("react-leaflet-markercluster").then((mod) => ({ default: mod.default })));
+function Map({ zoom = 15, maxZoom = 18, className, ...props }) {
+	return /* @__PURE__ */ jsx(LeafletMapContainer, {
+		zoom,
+		maxZoom,
+		attributionControl: false,
+		zoomControl: false,
+		className: cn("z-50 size-full min-h-96 flex-1 rounded-md", className),
+		...props
+	});
+}
+const MapLayersContext = createContext(null);
+function useMapLayersContext() {
+	return useContext(MapLayersContext);
+}
+function MapTileLayer({ name = "Default", url, attribution, darkUrl, darkAttribution, ...props }) {
+	const map = _useMap();
+	if (map.attributionControl) map.attributionControl.setPrefix("");
+	const context = useContext(MapLayersContext);
+	const DEFAULT_URL = "https://{s}.basemaps.cartocdn.com/light_all/{z}/{x}/{y}.png";
+	const DEFAULT_DARK_URL = "https://{s}.basemaps.cartocdn.com/dark_all/{z}/{x}/{y}.png";
+	const { resolvedTheme } = useTheme();
+	const resolvedUrl = resolvedTheme === "dark" ? darkUrl ?? url ?? DEFAULT_DARK_URL : url ?? DEFAULT_URL;
+	const resolvedAttribution = resolvedTheme === "dark" && darkAttribution ? darkAttribution : attribution ?? "&copy; <a href=\"http://www.openstreetmap.org/copyright\">OpenStreetMap</a>, &copy; <a href=\"https://carto.com/attributions\">CARTO</a>";
+	useEffect(() => {
+		if (context) context.registerTileLayer({
+			name,
+			url: resolvedUrl,
+			attribution: resolvedAttribution
+		});
+	}, [
+		context,
+		name,
+		url,
+		attribution
+	]);
+	if (context && context.selectedTileLayer !== name) return null;
+	return /* @__PURE__ */ jsx(LeafletTileLayer, {
+		url: resolvedUrl,
+		attribution: resolvedAttribution,
+		...props
+	});
+}
+function MapLayerGroup({ name, disabled, ...props }) {
+	const context = useMapLayersContext();
+	useEffect(() => {
+		if (context) context.registerLayerGroup({
+			name,
+			disabled
+		});
+	}, [
+		context,
+		name,
+		disabled
+	]);
+	if (context && !context.activeLayerGroups.includes(name)) return null;
+	return /* @__PURE__ */ jsx(LeafletLayerGroup, { ...props });
+}
+function MapFeatureGroup({ name, disabled, ...props }) {
+	const context = useMapLayersContext();
+	useEffect(() => {
+		if (context) context.registerLayerGroup({
+			name,
+			disabled
+		});
+	}, [
+		context,
+		name,
+		disabled
+	]);
+	if (context && !context.activeLayerGroups.includes(name)) return null;
+	return /* @__PURE__ */ jsx(LeafletFeatureGroup, { ...props });
+}
+function MapLayers({ defaultTileLayer, defaultLayerGroups = [], ...props }) {
+	const [tileLayers, setTileLayers] = useState([]);
+	const [selectedTileLayer, setSelectedTileLayer] = useState(defaultTileLayer || "");
+	const [layerGroups, setLayerGroups] = useState([]);
+	const [activeLayerGroups, setActiveLayerGroups] = useState(defaultLayerGroups);
+	function registerTileLayer(tileLayer) {
+		setTileLayers((prevTileLayers) => {
+			if (prevTileLayers.some((layer) => layer.name === tileLayer.name)) return prevTileLayers;
+			return [...prevTileLayers, tileLayer];
+		});
+	}
+	function registerLayerGroup(layerGroup) {
+		setLayerGroups((prevLayerGroups) => {
+			if (prevLayerGroups.some((group) => group.name === layerGroup.name)) return prevLayerGroups;
+			return [...prevLayerGroups, layerGroup];
+		});
+	}
+	useEffect(() => {
+		if (defaultTileLayer && tileLayers.length > 0 && !tileLayers.some((tileLayer) => tileLayer.name === defaultTileLayer)) throw new Error(`Invalid defaultTileLayer "${defaultTileLayer}" provided to MapLayers. It must match a MapTileLayer's name prop.`);
+		if (tileLayers.length > 0 && !selectedTileLayer) setSelectedTileLayer(defaultTileLayer && tileLayers.some((layer) => layer.name === defaultTileLayer) ? defaultTileLayer : tileLayers[0].name);
+		if (defaultLayerGroups.length > 0 && layerGroups.length > 0 && defaultLayerGroups.some((name) => !layerGroups.some((group) => group.name === name))) throw new Error(`Invalid defaultLayerGroups value provided to MapLayers. All names must match a MapLayerGroup's name prop.`);
+	}, [
+		tileLayers,
+		defaultTileLayer,
+		selectedTileLayer,
+		layerGroups,
+		defaultLayerGroups
+	]);
+	return /* @__PURE__ */ jsx(MapLayersContext.Provider, {
+		value: {
+			registerTileLayer,
+			tileLayers,
+			selectedTileLayer,
+			setSelectedTileLayer,
+			registerLayerGroup,
+			layerGroups,
+			activeLayerGroups,
+			setActiveLayerGroups
+		},
+		...props
+	});
+}
+function MapLayersControl({ tileLayersLabel = "Map Type", layerGroupsLabel = "Layers", position = "top-1 right-1", className, ...props }) {
+	const layersContext = useMapLayersContext();
+	if (!layersContext) throw new Error("MapLayersControl must be used within MapLayers");
+	const { tileLayers, selectedTileLayer, setSelectedTileLayer, layerGroups, activeLayerGroups, setActiveLayerGroups } = layersContext;
+	if (tileLayers.length === 0 && layerGroups.length === 0) return null;
+	function handleLayerGroupToggle(name, checked) {
+		setActiveLayerGroups(checked ? [...activeLayerGroups, name] : activeLayerGroups.filter((groupName) => groupName !== name));
+	}
+	const showTileLayersDropdown = tileLayers.length > 1;
+	const showLayerGroupsDropdown = layerGroups.length > 0;
+	if (!showTileLayersDropdown && !showLayerGroupsDropdown) return null;
+	return /* @__PURE__ */ jsxs(DropdownMenu, { children: [/* @__PURE__ */ jsx(DropdownMenuTrigger, {
+		asChild: true,
+		children: /* @__PURE__ */ jsx(Button, {
+			type: "button",
+			variant: "secondary",
+			size: "sm",
+			"aria-label": "Select layers",
+			title: "Select layers",
+			className: cn("absolute z-1000 border", position, className),
+			...props,
+			children: /* @__PURE__ */ jsx(LayersIcon, {})
+		})
+	}), /* @__PURE__ */ jsxs(DropdownMenuContent, {
+		align: "end",
+		className: "z-1000",
+		children: [
+			showTileLayersDropdown && /* @__PURE__ */ jsxs(Fragment$1, { children: [/* @__PURE__ */ jsx(DropdownMenuLabel, { children: tileLayersLabel }), /* @__PURE__ */ jsx(DropdownMenuRadioGroup, {
+				value: selectedTileLayer,
+				onValueChange: setSelectedTileLayer,
+				children: tileLayers.map((tileLayer) => /* @__PURE__ */ jsx(DropdownMenuRadioItem, {
+					value: tileLayer.name,
+					children: tileLayer.name
+				}, tileLayer.name))
+			})] }),
+			showTileLayersDropdown && showLayerGroupsDropdown && /* @__PURE__ */ jsx(DropdownMenuSeparator, {}),
+			showLayerGroupsDropdown && /* @__PURE__ */ jsxs(Fragment$1, { children: [/* @__PURE__ */ jsx(DropdownMenuLabel, { children: layerGroupsLabel }), layerGroups.map((layerGroup) => /* @__PURE__ */ jsx(DropdownMenuCheckboxItem, {
+				checked: activeLayerGroups.includes(layerGroup.name),
+				disabled: layerGroup.disabled,
+				onCheckedChange: (checked) => handleLayerGroupToggle(layerGroup.name, checked),
+				children: layerGroup.name
+			}, layerGroup.name))] })
+		]
+	})] });
+}
+function MapMarker({ icon = /* @__PURE__ */ jsx(MapPinIcon, { className: "size-6" }), iconAnchor = [12, 12], bgPos, popupAnchor, tooltipAnchor, ...props }) {
+	const { L } = useLeaflet();
+	if (!L) return null;
+	return /* @__PURE__ */ jsx(LeafletMarker, {
+		icon: L.divIcon({
+			html: renderToString(icon),
+			iconAnchor,
+			...bgPos ? { bgPos } : {},
+			...popupAnchor ? { popupAnchor } : {},
+			...tooltipAnchor ? { tooltipAnchor } : {}
+		}),
+		riseOnHover: true,
+		...props
+	});
+}
+function MapMarkerClusterGroup({ polygonOptions = { className: "fill-foreground stroke-foreground stroke-2" }, spiderLegPolylineOptions = { className: "fill-foreground stroke-foreground stroke-2" }, icon, ...props }) {
+	const { L } = useLeaflet();
+	if (!L) return null;
+	return /* @__PURE__ */ jsx(LeafletMarkerClusterGroup, {
+		polygonOptions,
+		spiderLegPolylineOptions,
+		iconCreateFunction: icon ? (cluster) => {
+			const iconNode = icon(cluster.getChildCount());
+			return L.divIcon({ html: renderToString(iconNode) });
+		} : void 0,
+		...props
+	});
+}
+function MapCircle({ className, ...props }) {
+	return /* @__PURE__ */ jsx(LeafletCircle, {
+		className: cn("fill-foreground stroke-foreground stroke-2", className),
+		...props
+	});
+}
+function MapCircleMarker({ className, ...props }) {
+	return /* @__PURE__ */ jsx(LeafletCircleMarker, {
+		className: cn("fill-foreground stroke-foreground stroke-2", className),
+		...props
+	});
+}
+function MapPolyline({ className, ...props }) {
+	return /* @__PURE__ */ jsx(LeafletPolyline, {
+		className: cn("fill-foreground stroke-foreground stroke-2", className),
+		...props
+	});
+}
+function MapPolygon({ className, ...props }) {
+	return /* @__PURE__ */ jsx(LeafletPolygon, {
+		className: cn("fill-foreground stroke-foreground stroke-2", className),
+		...props
+	});
+}
+function MapRectangle({ className, ...props }) {
+	return /* @__PURE__ */ jsx(LeafletRectangle, {
+		className: cn("fill-foreground stroke-foreground stroke-2", className),
+		...props
+	});
+}
+function MapPopup({ className, ...props }) {
+	return /* @__PURE__ */ jsx(LeafletPopup, {
+		className: cn("bg-popover text-popover-foreground animate-in fade-out-0 fade-in-0 zoom-out-95 zoom-in-95 slide-in-from-bottom-2 z-50 w-72 rounded-md border p-4 font-sans shadow-md outline-hidden", className),
+		...props
+	});
+}
+function MapTooltip({ className, children, side = "top", sideOffset = 15, ...props }) {
+	const ARROW_POSITION_CLASSES = {
+		top: "bottom-0.5 left-1/2 -translate-x-1/2 translate-y-1/2",
+		bottom: "top-0.5 left-1/2 -translate-x-1/2 -translate-y-1/2",
+		left: "right-0.5 top-1/2 translate-x-1/2 -translate-y-1/2",
+		right: "left-0.5 top-1/2 -translate-x-1/2 -translate-y-1/2"
+	};
+	const DEFAULT_OFFSET = {
+		top: [0, -sideOffset],
+		bottom: [0, sideOffset],
+		left: [-sideOffset, 0],
+		right: [sideOffset, 0]
+	};
+	return /* @__PURE__ */ jsxs(LeafletTooltip, {
+		className: cn("animate-in fade-in-0 zoom-in-95 fade-out-0 zoom-out-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 relative z-50 w-fit text-xs text-balance transition-opacity", className),
+		"data-side": side,
+		direction: side,
+		offset: DEFAULT_OFFSET[side],
+		opacity: 1,
+		...props,
+		children: [children, /* @__PURE__ */ jsx("div", { className: cn("bg-foreground fill-foreground absolute z-50 size-2.5 rotate-45 rounded-[2px]", ARROW_POSITION_CLASSES[side]) })]
+	});
+}
+function MapZoomControl({ position = "top-1 left-1", className, ...props }) {
+	const map = _useMap();
+	const [zoomLevel, setZoomLevel] = useState(map.getZoom());
+	_useMapEvents({ zoomend: () => {
+		setZoomLevel(map.getZoom());
+	} });
+	return /* @__PURE__ */ jsx(MapControlContainer, {
+		className: cn(position, className),
+		children: /* @__PURE__ */ jsxs(ButtonGroup, {
+			orientation: "vertical",
+			"aria-label": "Zoom controls",
+			...props,
+			children: [/* @__PURE__ */ jsx(Button, {
+				type: "button",
+				size: "icon",
+				variant: "outline",
+				"aria-label": "Zoom in",
+				title: "Zoom in",
+				className: "border",
+				disabled: zoomLevel >= map.getMaxZoom(),
+				onClick: () => map.zoomIn(),
+				children: /* @__PURE__ */ jsx(PlusIcon, {})
+			}), /* @__PURE__ */ jsx(Button, {
+				type: "button",
+				size: "icon",
+				variant: "outline",
+				"aria-label": "Zoom out",
+				title: "Zoom out",
+				className: "border",
+				disabled: zoomLevel <= map.getMinZoom(),
+				onClick: () => map.zoomOut(),
+				children: /* @__PURE__ */ jsx(MinusIcon, {})
+			})]
+		})
+	});
+}
+function MapFullscreenControl({ position = "top-1 right-1", className, ...props }) {
+	const map = _useMap();
+	const [isFullscreen, setIsFullscreen] = useState(false);
+	const { L } = useLeaflet();
+	useEffect(() => {
+		if (!L) return;
+		const fullscreenControl = new L.Control.FullScreen();
+		fullscreenControl.addTo(map);
+		const container = fullscreenControl.getContainer();
+		if (container) container.style.display = "none";
+		const handleEnter = () => setIsFullscreen(true);
+		const handleExit = () => setIsFullscreen(false);
+		map.on("enterFullscreen", handleEnter);
+		map.on("exitFullscreen", handleExit);
+		return () => {
+			fullscreenControl.remove();
+			map.off("enterFullscreen", handleEnter);
+			map.off("exitFullscreen", handleExit);
+		};
+	}, [L, map]);
+	return /* @__PURE__ */ jsx(MapControlContainer, {
+		className: cn(position, className),
+		children: /* @__PURE__ */ jsx(Button, {
+			type: "button",
+			size: "icon",
+			variant: "outline",
+			onClick: () => map.toggleFullscreen(),
+			"aria-label": isFullscreen ? "Exit fullscreen" : "Enter fullscreen",
+			title: isFullscreen ? "Exit fullscreen" : "Enter fullscreen",
+			className: "border",
+			...props,
+			children: isFullscreen ? /* @__PURE__ */ jsx(MinimizeIcon, {}) : /* @__PURE__ */ jsx(MaximizeIcon, {})
+		})
+	});
+}
+function MapLocatePulseIcon() {
+	return /* @__PURE__ */ jsxs("div", {
+		className: "absolute -top-1 -right-1 flex size-3 rounded-full",
+		children: [/* @__PURE__ */ jsx("div", { className: "bg-primary absolute inline-flex size-full animate-ping rounded-full opacity-75" }), /* @__PURE__ */ jsx("div", { className: "bg-primary relative inline-flex size-3 rounded-full" })]
+	});
+}
+function MapLocateControl({ watch = false, onLocationFound, onLocationError, position = "right-1 bottom-1", className, ...props }) {
+	const map = _useMap();
+	const [isLocating, setIsLocating] = useDebounceLoadingState(200);
+	const [location, setLocation] = useState(null);
+	function startLocating() {
+		setIsLocating(true);
+		map.locate({
+			setView: true,
+			maxZoom: map.getMaxZoom(),
+			watch
+		});
+		map.on("locationfound", (location) => {
+			setLocation(location.latlng);
+			setIsLocating(false);
+			onLocationFound?.(location);
+		});
+		map.on("locationerror", (error) => {
+			setLocation(null);
+			setIsLocating(false);
+			onLocationError?.(error);
+		});
+	}
+	function stopLocating() {
+		map.stopLocate();
+		map.off("locationfound");
+		map.off("locationerror");
+		setLocation(null);
+		setIsLocating(false);
+	}
+	useEffect(() => () => stopLocating(), []);
+	return /* @__PURE__ */ jsxs(MapControlContainer, {
+		className: cn(position, className),
+		children: [/* @__PURE__ */ jsx(Button, {
+			type: "button",
+			size: "sm",
+			variant: location ? "default" : "secondary",
+			onClick: location ? stopLocating : startLocating,
+			disabled: isLocating,
+			title: isLocating ? "Locating..." : location ? "Stop tracking" : "Track location",
+			"aria-label": isLocating ? "Locating..." : location ? "Stop location tracking" : "Start location tracking",
+			className: "border",
+			...props,
+			children: isLocating ? /* @__PURE__ */ jsx(LoaderCircleIcon, { className: "animate-spin" }) : /* @__PURE__ */ jsx(NavigationIcon, {})
+		}), location && /* @__PURE__ */ jsx(MapMarker, {
+			position: location,
+			icon: /* @__PURE__ */ jsx(MapLocatePulseIcon, {})
+		})]
+	});
+}
+function MapSearchControl({ position = "top-1 left-1", className, ...props }) {
+	return /* @__PURE__ */ jsx(MapControlContainer, {
+		className: cn("z-1001 w-60", position, className),
+		children: /* @__PURE__ */ jsx(PlaceAutocomplete, { ...props })
+	});
+}
+const MapDrawContext = createContext(null);
+function useMapDrawContext() {
+	return useContext(MapDrawContext);
+}
+function MapDrawControl({ onLayersChange, position = "bottom-1 left-1", className, ...props }) {
+	const { L, LeafletDraw } = useLeaflet();
+	const map = _useMap();
+	const featureGroupRef = useRef(null);
+	const editControlRef = useRef(null);
+	const deleteControlRef = useRef(null);
+	const [activeMode, setActiveMode] = useState(null);
+	const [layersCount, setLayersCount] = useState(0);
+	function updateLayersCount() {
+		if (featureGroupRef.current) setLayersCount(featureGroupRef.current.getLayers().length);
+	}
+	function handleDrawCreated(event) {
+		if (!featureGroupRef.current) return;
+		const { layer } = event;
+		featureGroupRef.current.addLayer(layer);
+		onLayersChange?.(featureGroupRef.current);
+		updateLayersCount();
+		setActiveMode(null);
+	}
+	function handleDrawEditedOrDeleted() {
+		if (!featureGroupRef.current) return;
+		onLayersChange?.(featureGroupRef.current);
+		updateLayersCount();
+		setActiveMode(null);
+	}
+	useEffect(() => {
+		if (!L || !LeafletDraw || !map) return;
+		map.on(L.Draw.Event.CREATED, handleDrawCreated);
+		map.on(L.Draw.Event.EDITED, handleDrawEditedOrDeleted);
+		map.on(L.Draw.Event.DELETED, handleDrawEditedOrDeleted);
+		return () => {
+			map.off(L.Draw.Event.CREATED, handleDrawCreated);
+			map.off(L.Draw.Event.EDITED, handleDrawEditedOrDeleted);
+			map.off(L.Draw.Event.DELETED, handleDrawEditedOrDeleted);
+		};
+	}, [
+		L,
+		LeafletDraw,
+		map,
+		onLayersChange
+	]);
+	return /* @__PURE__ */ jsxs(MapDrawContext.Provider, {
+		value: {
+			featureGroup: featureGroupRef.current,
+			activeMode,
+			setActiveMode,
+			editControlRef,
+			deleteControlRef,
+			layersCount
+		},
+		children: [/* @__PURE__ */ jsx(LeafletFeatureGroup, { ref: featureGroupRef }), /* @__PURE__ */ jsx(MapControlContainer, {
+			className: cn(position, className),
+			children: /* @__PURE__ */ jsx(ButtonGroup, {
+				orientation: "vertical",
+				...props
+			})
+		})]
+	});
+}
+function MapDrawShapeButton({ drawMode, createDrawTool, className, ...props }) {
+	const drawContext = useMapDrawContext();
+	if (!drawContext) throw new Error("MapDrawShapeButton must be used within MapDrawControl");
+	const { L } = useLeaflet();
+	const map = _useMap();
+	const controlRef = useRef(null);
+	const { activeMode, setActiveMode } = drawContext;
+	const isActive = activeMode === drawMode;
+	useEffect(() => {
+		if (!L || !isActive) {
+			controlRef.current?.disable();
+			controlRef.current = null;
+			return;
+		}
+		const control = createDrawTool(L, map);
+		control.enable();
+		controlRef.current = control;
+		return () => {
+			control.disable();
+			controlRef.current = null;
+		};
+	}, [
+		L,
+		map,
+		isActive,
+		createDrawTool
+	]);
+	function handleClick() {
+		setActiveMode(isActive ? null : drawMode);
+	}
+	return /* @__PURE__ */ jsx(Button, {
+		type: "button",
+		size: "sm",
+		"aria-label": `Draw ${drawMode}`,
+		title: `Draw ${drawMode}`,
+		className: cn("border", className),
+		variant: isActive ? "default" : "secondary",
+		disabled: activeMode === "edit" || activeMode === "delete",
+		onClick: handleClick,
+		...props
+	});
+}
+function MapDrawMarker({ ...props }) {
+	return /* @__PURE__ */ jsx(MapDrawShapeButton, {
+		drawMode: "marker",
+		createDrawTool: (L, map) => new L.Draw.Marker(map, {
+			icon: L.divIcon({
+				className: "",
+				iconAnchor: [12, 12],
+				html: renderToString(/* @__PURE__ */ jsx(MapPinIcon, { className: "size-6" }))
+			}),
+			...props
+		}),
+		children: /* @__PURE__ */ jsx(MapPinIcon, {})
+	});
+}
+function MapDrawPolyline({ showLength = false, drawError = { color: "var(--color-destructive)" }, shapeOptions = {
+	color: "var(--color-primary)",
+	opacity: 1,
+	weight: 2
+}, ...props }) {
+	const mapDrawHandleIcon = useMapDrawHandleIcon();
+	return /* @__PURE__ */ jsx(MapDrawShapeButton, {
+		drawMode: "polyline",
+		createDrawTool: (L, map) => new L.Draw.Polyline(map, {
+			...mapDrawHandleIcon ? {
+				icon: mapDrawHandleIcon,
+				touchIcon: mapDrawHandleIcon
+			} : {},
+			showLength,
+			drawError,
+			shapeOptions,
+			...props
+		}),
+		children: /* @__PURE__ */ jsx(WaypointsIcon, {})
+	});
+}
+function MapDrawCircle({ showRadius = false, shapeOptions = {
+	color: "var(--color-primary)",
+	opacity: 1,
+	weight: 2
+}, ...props }) {
+	return /* @__PURE__ */ jsx(MapDrawShapeButton, {
+		drawMode: "circle",
+		createDrawTool: (L, map) => new L.Draw.Circle(map, {
+			showRadius,
+			shapeOptions,
+			...props
+		}),
+		children: /* @__PURE__ */ jsx(CircleIcon, {})
+	});
+}
+function MapDrawRectangle({ showArea = false, shapeOptions = {
+	color: "var(--color-primary)",
+	opacity: 1,
+	weight: 2
+}, ...props }) {
+	return /* @__PURE__ */ jsx(MapDrawShapeButton, {
+		drawMode: "rectangle",
+		createDrawTool: (L, map) => new L.Draw.Rectangle(map, {
+			showArea,
+			shapeOptions,
+			...props
+		}),
+		children: /* @__PURE__ */ jsx(SquareIcon, {})
+	});
+}
+function MapDrawPolygon({ drawError = { color: "var(--color-destructive)" }, shapeOptions = {
+	color: "var(--color-primary)",
+	opacity: 1,
+	weight: 2
+}, ...props }) {
+	const mapDrawHandleIcon = useMapDrawHandleIcon();
+	return /* @__PURE__ */ jsx(MapDrawShapeButton, {
+		drawMode: "polygon",
+		createDrawTool: (L, map) => new L.Draw.Polygon(map, {
+			...mapDrawHandleIcon ? {
+				icon: mapDrawHandleIcon,
+				touchIcon: mapDrawHandleIcon
+			} : {},
+			drawError,
+			shapeOptions,
+			...props
+		}),
+		children: /* @__PURE__ */ jsx(PentagonIcon, {})
+	});
+}
+function MapDrawActionButton({ drawAction, createDrawTool, controlRef, className, ...props }) {
+	const drawContext = useMapDrawContext();
+	if (!drawContext) throw new Error("MapDrawActionButton must be used within MapDrawControl");
+	const { L } = useLeaflet();
+	const map = _useMap();
+	const { featureGroup, activeMode, setActiveMode, layersCount } = drawContext;
+	const isActive = activeMode === drawAction;
+	const hasFeatures = layersCount > 0;
+	useEffect(() => {
+		if (!L || !featureGroup || !isActive) {
+			controlRef.current?.disable?.();
+			controlRef.current = null;
+			return;
+		}
+		const control = createDrawTool(L, map, featureGroup);
+		control.enable?.();
+		controlRef.current = control;
+		return () => {
+			control.disable?.();
+			controlRef.current = null;
+		};
+	}, [
+		L,
+		map,
+		isActive,
+		featureGroup,
+		createDrawTool
+	]);
+	function handleClick() {
+		controlRef.current?.save();
+		setActiveMode(isActive ? null : drawAction);
+	}
+	return /* @__PURE__ */ jsx(Button, {
+		type: "button",
+		size: "sm",
+		"aria-label": `${drawAction === "edit" ? "Edit" : "Remove"} shapes`,
+		title: `${drawAction === "edit" ? "Edit" : "Remove"} shapes`,
+		variant: isActive ? "default" : "secondary",
+		disabled: !hasFeatures,
+		onClick: handleClick,
+		className: cn("border", className),
+		...props
+	});
+}
+function MapDrawEdit({ selectedPathOptions = {
+	color: "var(--color-primary)",
+	fillColor: "var(--color-primary)",
+	weight: 2
+}, ...props }) {
+	const { L } = useLeaflet();
+	const mapDrawHandleIcon = useMapDrawHandleIcon();
+	const drawContext = useMapDrawContext();
+	if (!drawContext) throw new Error("MapDrawEdit must be used within MapDrawControl");
+	useEffect(() => {
+		if (!L || !mapDrawHandleIcon) return;
+		L.Edit.PolyVerticesEdit.mergeOptions({
+			icon: mapDrawHandleIcon,
+			touchIcon: mapDrawHandleIcon,
+			drawError: { color: "var(--color-destructive)" }
+		});
+		L.Edit.SimpleShape.mergeOptions({
+			moveIcon: mapDrawHandleIcon,
+			resizeIcon: mapDrawHandleIcon,
+			touchMoveIcon: mapDrawHandleIcon,
+			touchResizeIcon: mapDrawHandleIcon
+		});
+		L.drawLocal.edit.handlers.edit.tooltip = {
+			text: "Drag handles or markers to edit.",
+			subtext: ""
+		};
+		L.drawLocal.edit.handlers.remove.tooltip = { text: "Click on a shape to remove." };
+	}, [mapDrawHandleIcon]);
+	return /* @__PURE__ */ jsx(MapDrawActionButton, {
+		drawAction: "edit",
+		controlRef: drawContext.editControlRef,
+		createDrawTool: (L, map, featureGroup) => new L.EditToolbar.Edit(map, {
+			featureGroup,
+			selectedPathOptions,
+			...props
+		}),
+		children: /* @__PURE__ */ jsx(PenLineIcon, {})
+	});
+}
+function MapDrawDelete() {
+	const drawContext = useMapDrawContext();
+	if (!drawContext) throw new Error("MapDrawDelete must be used within MapDrawControl");
+	return /* @__PURE__ */ jsx(MapDrawActionButton, {
+		drawAction: "delete",
+		controlRef: drawContext.deleteControlRef,
+		createDrawTool: (L, map, featureGroup) => new L.EditToolbar.Delete(map, { featureGroup }),
+		children: /* @__PURE__ */ jsx(Trash2Icon, {})
+	});
+}
+function MapDrawUndo({ className, ...props }) {
+	const drawContext = useMapDrawContext();
+	if (!drawContext) throw new Error("MapDrawUndo must be used within MapDrawControl");
+	const { activeMode, setActiveMode, editControlRef, deleteControlRef, layersCount } = drawContext;
+	const isInEditMode = activeMode === "edit";
+	const isInDeleteMode = activeMode === "delete";
+	const isActive = (isInEditMode || isInDeleteMode) && layersCount > 0;
+	function handleUndo() {
+		if (isInEditMode) editControlRef.current?.revertLayers();
+		else if (isInDeleteMode) deleteControlRef.current?.revertLayers();
+		setActiveMode(null);
+	}
+	return /* @__PURE__ */ jsx(Button, {
+		type: "button",
+		size: "sm",
+		variant: "secondary",
+		"aria-label": `Undo ${activeMode}`,
+		title: `Undo ${activeMode}`,
+		onClick: handleUndo,
+		disabled: !isActive,
+		className: cn("border", className),
+		...props,
+		children: /* @__PURE__ */ jsx(Undo2Icon, {})
+	});
+}
+function MapControlContainer({ className, ...props }) {
+	const { L } = useLeaflet();
+	const containerRef = useRef(null);
+	useEffect(() => {
+		if (!L) return;
+		const element = containerRef.current;
+		if (!element) return;
+		L.DomEvent.disableClickPropagation(element);
+		L.DomEvent.disableScrollPropagation(element);
+	}, [L]);
+	return /* @__PURE__ */ jsx("div", {
+		ref: containerRef,
+		className: cn("absolute z-1000 size-fit cursor-default", className),
+		...props
+	});
+}
+function useMapDrawHandleIcon() {
+	const { L } = useLeaflet();
+	if (!L) return null;
+	return L.divIcon({
+		iconAnchor: [8, 8],
+		html: renderToString(/* @__PURE__ */ jsx(CircleIcon, { className: "fill-primary stroke-primary size-4 transition-transform hover:scale-110" }))
+	});
+}
+function useLeaflet() {
+	const [L, setL] = useState(null);
+	const [LeafletDraw, setLeafletDraw] = useState(null);
+	useEffect(() => {
+		async function loadLeaflet() {
+			const leaflet = await import("leaflet");
+			const leafletFullscreen = await import("leaflet.fullscreen");
+			const leafletDraw = await import("leaflet-draw");
+			const L_object = leaflet.default;
+			if (L_object.Control && !L_object.Control.FullScreen) L_object.Control.FullScreen = leafletFullscreen.default || leafletFullscreen;
+			setLeafletDraw(leafletDraw);
+			setL(L_object);
+		}
+		if (L && LeafletDraw) return;
+		if (typeof window === "undefined") return;
+		loadLeaflet();
+	}, [L, LeafletDraw]);
+	return {
+		L,
+		LeafletDraw
+	};
+}
+function useDebounceLoadingState(delay = 200) {
+	const [isLoading, setIsLoading] = useState(false);
+	const [showLoading, setShowLoading] = useState(false);
+	const timeoutRef = useRef(null);
+	useEffect(() => {
+		if (isLoading) timeoutRef.current = setTimeout(() => {
+			setShowLoading(true);
+		}, delay);
+		else {
+			if (timeoutRef.current) {
+				clearTimeout(timeoutRef.current);
+				timeoutRef.current = null;
+			}
+			setShowLoading(false);
+		}
+		return () => {
+			if (timeoutRef.current) clearTimeout(timeoutRef.current);
+		};
+	}, [isLoading, delay]);
+	return [showLoading, setIsLoading];
+}
+//#endregion
+export { useLeaflet as A, MapPolyline as C, MapTileLayer as D, MapSearchControl as E, MapTooltip as O, MapPolygon as S, MapRectangle as T, MapLayers as _, MapDrawCircle as a, MapMarker as b, MapDrawEdit as c, MapDrawPolyline as d, MapDrawRectangle as f, MapLayerGroup as g, MapFullscreenControl as h, MapControlContainer as i, PlaceAutocomplete as j, MapZoomControl as k, MapDrawMarker as l, MapFeatureGroup as m, MapCircle as n, MapDrawControl as o, MapDrawUndo as p, MapCircleMarker as r, MapDrawDelete as s, Map as t, MapDrawPolygon as u, MapLayersControl as v, MapPopup as w, MapMarkerClusterGroup as x, MapLocateControl as y };