@radiofrance/svelte-leaflet 0.1.0-alpha.9 → 1.0.0-next.0

package/dist/Popup.svelte

@@ -1,48 +1,73 @@
-<script>import { getContext, onDestroy, onMount, tick } from "svelte";
-const L = globalThis.window.L;
-export let options = {
-  autoPan: false
-};
-let popup = void 0;
-let popupElement;
-let showContents = false;
-let popupOpen = false;
-const getLayer = getContext("layer");
-let layer;
-function removePopup() {
-  if (!popup)
-    return;
-  layer.unbindPopup();
-  popup.remove();
-}
-async function createPopup() {
-  await tick();
-  layer = getLayer();
-  popup = L.popup().setContent(popupElement);
-  layer.bindPopup(popup, options);
-  layer.on("popupopen", async () => {
-    popupOpen = true;
-    showContents = true;
-    await tick();
-    popup?.update();
-  });
-  layer.on("popupclose", async () => {
-    popupOpen = false;
-    setTimeout(() => {
-      if (!popupOpen) {
-        showContents = false;
-      }
-    }, 200);
-  });
-}
-onMount(createPopup);
-onDestroy(() => {
-  removePopup();
-});
+<script lang="ts">
+	import type {
+		LatLngExpression,
+		PopupOptions,
+		LayerGroup,
+		Popup as LeafletPopup,
+		Map as LeafletMap,
+		Marker as LeafletMarker,
+	} from 'leaflet';
+	import { getContext, onDestroy, onMount, type Snippet } from 'svelte';
+	import { bindEvents } from './index.js';
+	import { popupEvents, updatePopupProps, type PopupEvents } from './popup.svelte.js';
+	import { LAYERGROUP, MAP, MARKER } from './contexts.js';
+
+	type Props = {
+		latlng?: LatLngExpression;
+		options?: PopupOptions;
+		instance?: LeafletPopup;
+		children?: Snippet;
+	} & PopupEvents;
+
+	let {
+		latlng,
+		options = $bindable({}),
+		instance = $bindable(),
+		children,
+		...restProps
+	}: Props = $props();
+
+	let popupContent: HTMLElement | undefined = $state();
+
+	const getMap = getContext<() => LeafletMap>(MAP);
+	const getLayerGroup = getContext<() => LayerGroup>(LAYERGROUP);
+	const getMarker = getContext<() => LeafletMarker>(MARKER);
+
+	onMount(() => {
+		const map = getMap?.();
+		const layerGroup = getLayerGroup?.();
+		const marker = getMarker?.();
+		const context = layerGroup || map;
+		instance = window.L.popup(options);
+		if (latlng) instance.setLatLng(latlng);
+		bindEvents(instance, restProps, popupEvents);
+		if (marker) marker.bindPopup(instance);
+		else if (map) instance.openOn(map);
+		else instance.addTo(context);
+		if (popupContent) instance.setContent(popupContent);
+	});
+
+	onDestroy(() => {
+		instance?.remove();
+	});
+
+	$effect(() => {
+		if (instance && options) {
+			updatePopupProps(instance, options);
+		}
+	});
 </script>
 
-<div bind:this={popupElement}>
-	{#if showContents}
-		<slot />
+<div class="container">
+	{#if children}
+		<div bind:this={popupContent} class="PopupChildrenContainer">
+			{@render children()}
+		</div>
 	{/if}
 </div>
+
+<style>
+	.container {
+		display: none;
+	}
+</style>

package/dist/Popup.svelte.d.ts

@@ -1,19 +1,10 @@
-import { SvelteComponent } from "svelte";
-import type { PopupOptions } from 'leaflet';
-declare const __propDef: {
-    props: {
-        options?: PopupOptions | undefined;
-    };
-    events: {
-        [evt: string]: CustomEvent<any>;
-    };
-    slots: {
-        default: {};
-    };
-};
-export type PopupProps = typeof __propDef.props;
-export type PopupEvents = typeof __propDef.events;
-export type PopupSlots = typeof __propDef.slots;
-export default class Popup extends SvelteComponent<PopupProps, PopupEvents, PopupSlots> {
-}
-export {};
+import type { LatLngExpression, PopupOptions, Popup as LeafletPopup } from 'leaflet';
+import { type Snippet } from 'svelte';
+import { type PopupEvents } from './popup.svelte.js';
+declare const Popup: import("svelte").Component<{
+    latlng?: LatLngExpression;
+    options?: PopupOptions;
+    instance?: LeafletPopup;
+    children?: Snippet;
+} & PopupEvents, {}, "instance" | "options">;
+export default Popup;

package/dist/contexts.d.ts

@@ -0,0 +1,4 @@
+export declare const MAP: unique symbol;
+export declare const LAYERGROUP: unique symbol;
+export declare const MARKER: unique symbol;
+export declare const FOCUSABLE: unique symbol;

package/dist/contexts.js

@@ -0,0 +1,4 @@
+export const MAP = Symbol('map');
+export const LAYERGROUP = Symbol('layerGroup');
+export const MARKER = Symbol('marker');
+export const FOCUSABLE = Symbol('focusable');

package/dist/events.d.ts

@@ -0,0 +1,11 @@
+export declare const interactiveLayerEvents: readonly ["click", "dblclick", "mousedown", "mouseup", "mouseover", "mouseout", "contextmenu"];
+export declare const draggingEvents: readonly ["dragstart", "movestart", "drag", "dragend", "moveend"];
+export declare const keyboardEvents: readonly ["keypress", "keydown", "keyup"];
+export declare const locationEvents: readonly ["locationfound", "locationerror"];
+export declare const leafletMouseEvents: readonly ["click", "dblclick", "mousedown", "mouseup", "mouseover", "mouseout", "contextmenu", "mousemove", "preclick"];
+export declare const layerEvents: readonly ["add", "remove"];
+export declare const popupSpecificEvents: readonly ["popupopen", "popupclose"];
+export declare const tooltipEvents: readonly ["tooltipopen", "tooltipclose"];
+export declare const layerGroupEvents: readonly ["layeradd", "layerremove"];
+export declare const layersControlEvents: readonly ["baselayerchange", "overlayadd", "overlayremove"];
+export declare const mapStateChangeEvents: readonly ["load", "move", "moveend", "movestart", "unload", "viewreset", "zoom", "zoomend", "zoomlevelschange", "zoomstart", "resize"];

package/dist/events.js

@@ -0,0 +1,31 @@
+export const interactiveLayerEvents = [
+    'click',
+    'dblclick',
+    'mousedown',
+    'mouseup',
+    'mouseover',
+    'mouseout',
+    'contextmenu',
+];
+export const draggingEvents = ['dragstart', 'movestart', 'drag', 'dragend', 'moveend'];
+export const keyboardEvents = ['keypress', 'keydown', 'keyup'];
+export const locationEvents = ['locationfound', 'locationerror'];
+export const leafletMouseEvents = [...interactiveLayerEvents, 'mousemove', 'preclick'];
+export const layerEvents = ['add', 'remove'];
+export const popupSpecificEvents = ['popupopen', 'popupclose'];
+export const tooltipEvents = ['tooltipopen', 'tooltipclose'];
+export const layerGroupEvents = ['layeradd', 'layerremove'];
+export const layersControlEvents = ['baselayerchange', 'overlayadd', 'overlayremove'];
+const leafletEvents = [
+    'load',
+    'move',
+    'moveend',
+    'movestart',
+    'unload',
+    'viewreset',
+    'zoom',
+    'zoomend',
+    'zoomlevelschange',
+    'zoomstart',
+];
+export const mapStateChangeEvents = [...leafletEvents, 'resize'];

package/dist/index.d.ts

@@ -1,54 +1,19 @@
-import type { DragEndEvent, ErrorEvent, Evented, LayerEvent, LayersControlEvent, LeafletEvent, LeafletKeyboardEvent, LeafletMouseEvent, LocationEvent, PopupEvent, ResizeEvent, TooltipEvent } from 'leaflet';
-import type { EventDispatcher } from 'svelte';
-export { default as Map } from './Map.svelte';
-export { default as Marker } from './Marker.svelte';
-export { default as MarkerClusterGroup } from './MarkerClusterGroup.svelte';
-export { default as Polyline } from './Polyline.svelte';
-export { default as Popup } from './Popup.svelte';
-export { default as Circle } from './Circle.svelte';
-export type { Marker as LeafletMarker } from './Marker.svelte';
-export type { Circle as LeafletCircle, CircleOptions, DragEndEvent, ErrorEvent, LatLngExpression, LatLngLiteral, LatLngTuple, LayerEvent, LayersControlEvent, LeafletEvent, LeafletKeyboardEvent, LeafletMouseEvent, LocationEvent, Map as LeafletMap, MapOptions, MarkerOptions, PathOptions, PopupEvent, PopupOptions, ResizeEvent, TooltipEvent } from 'leaflet';
-export declare function bindEvents(instance: Evented, dispatch: EventDispatcher<Record<string, unknown>>, events: readonly string[]): void;
-export declare const interactiveLayerEvents: readonly ["click", "dblclick", "mousedown", "mouseup", "mouseover", "mouseout", "contextmenu"];
-export declare const keyboardEvents: readonly ["keypress", "keydown", "keyup"];
-export declare const locationEvents: readonly ["locationfound", "locationerror"];
-export declare const leafletMouseEvents: readonly ["click", "dblclick", "mousedown", "mouseup", "mouseover", "mouseout", "contextmenu", "mousemove", "preclick"];
-export declare const layerEvents: readonly ["add", "remove"];
-export declare const popupEvents: readonly ["popupopen", "popupclose"];
-export declare const tooltipEvents: readonly ["tooltipopen", "tooltipclose"];
-export declare const layerGroupEvents: readonly ["layeradd", "layerremove"];
-export declare const layersControlEvents: readonly ["baselayerchange", "overlayadd", "overlayremove"];
-declare const leafletEvents: readonly ["load", "move", "moveend", "movestart", "unload", "viewreset", "zoom", "zoomend", "zoomlevelschange", "zoomstart"];
-export declare const mapStateChangeEvents: readonly ["load", "move", "moveend", "movestart", "unload", "viewreset", "zoom", "zoomend", "zoomlevelschange", "zoomstart", "resize"];
-type LeafletEventTypes = {
-    resize: ResizeEvent;
-    locationerror: ErrorEvent;
-    locationfound: LocationEvent;
-    add: LeafletEvent;
-    remove: LeafletEvent;
-    dragend: DragEndEvent;
-} & LeafletEvents & LayersControlEvents & MouseEvents & PopupEvents & TooltipEvents & LayerGroupEvents & KeyboardEvents;
-type LeafletEvents = {
-    [K in (typeof leafletEvents)[number]]: LeafletEvent;
-};
-type LayersControlEvents = {
-    [K in (typeof layersControlEvents)[number]]: LayersControlEvent;
-};
-type MouseEvents = {
-    [K in (typeof leafletMouseEvents)[number]]: LeafletMouseEvent;
-};
-type PopupEvents = {
-    [K in (typeof popupEvents)[number]]: PopupEvent;
-};
-type TooltipEvents = {
-    [K in (typeof tooltipEvents)[number]]: TooltipEvent;
-};
-type LayerGroupEvents = {
-    [K in (typeof layerGroupEvents)[number]]: LayerEvent;
-};
-type KeyboardEvents = {
-    [K in (typeof keyboardEvents)[number]]: LeafletKeyboardEvent;
-};
-export type LeafletEventsRecord<T extends readonly string[]> = {
-    [K in T[number]]: K extends keyof LeafletEventTypes ? LeafletEventTypes[K] : LeafletEvent;
+import type { ControlPosition, Evented, LatLngExpression, LeafletEventHandlerFnMap, LocateOptions } from 'leaflet';
+import DivIcon from './DivIcon.svelte';
+import Map from './Map.svelte';
+import Marker from './Marker.svelte';
+import MarkerClusterGroup from './MarkerClusterGroup.svelte';
+import Popup from './Popup.svelte';
+import Polygon from './Polygon.svelte';
+import LocateControl from './LocateControl.svelte';
+export { DivIcon, Map, Marker, MarkerClusterGroup, Popup, Polygon, LocateControl };
+export type { Circle as LeafletCircle, CircleOptions, DragEndEvent, ErrorEvent, LatLngBoundsLiteral, LatLngExpression, LatLngLiteral, LatLngTuple, LayerEvent, LayersControlEvent, LeafletEvent, LeafletKeyboardEvent, LeafletMouseEvent, LocationEvent, Map as LeafletMap, MapOptions, MarkerOptions, PathOptions, PopupEvent, PopupOptions, ResizeEvent, TooltipEvent, } from 'leaflet';
+export type Latlngs<D = 2> = 2 extends D ? LatLngExpression[] | LatLngExpression[][] : 3 extends D ? LatLngExpression[] | LatLngExpression[][] | LatLngExpression[][][] : never;
+export type PrefixedLeafletEventHandlerFnMap = {
+    [K in keyof LeafletEventHandlerFnMap as `on${K}`]: LeafletEventHandlerFnMap[K];
+};
+export declare function bindEvents(instance: Evented, eventsProps: PrefixedLeafletEventHandlerFnMap, events: readonly (keyof LeafletEventHandlerFnMap)[]): void;
+export type LocateControlOptions = {
+    position?: ControlPosition;
+    options?: LocateOptions;
 };

package/dist/index.js

@@ -1,57 +1,17 @@
 // Reexport your entry components here
-export { default as Map } from './Map.svelte';
-export { default as Marker } from './Marker.svelte';
-export { default as MarkerClusterGroup } from './MarkerClusterGroup.svelte';
-export { default as Polyline } from './Polyline.svelte';
-export { default as Popup } from './Popup.svelte';
-export { default as Circle } from './Circle.svelte';
-export function bindEvents(instance, dispatch, events) {
+import DivIcon from './DivIcon.svelte';
+import Map from './Map.svelte';
+import Marker from './Marker.svelte';
+import MarkerClusterGroup from './MarkerClusterGroup.svelte';
+import Popup from './Popup.svelte';
+import Polygon from './Polygon.svelte';
+import LocateControl from './LocateControl.svelte';
+export { DivIcon, Map, Marker, MarkerClusterGroup, Popup, Polygon, LocateControl };
+export function bindEvents(instance, eventsProps, events) {
     events.forEach((event) => {
-        instance.on(event, (e) => dispatch(event, e));
+        const eventCallback = eventsProps[`on${event}`];
+        if (typeof eventCallback !== 'function')
+            return;
+        instance.on(event, (e) => eventCallback(e));
     });
 }
-// export const leafletEvents = [
-// 	'dragstart',
-// 	'drag',
-// 	'add',
-// 	'remove',
-// 	'loading',
-// 	'error',
-// 	'update',
-// 	'down',
-// 	'predrag'
-// ] as const;
-// export const resizeEvents = ['resize'] as const;
-// export const zoomAnimEvents = ['zoomanim'] as const;
-// export const tileEvents = ['tileunload', 'tileloadstart', 'tileload', 'tileabort'] as const;
-// export const tileErrorEvents = ['tileerror'] as const;
-export const interactiveLayerEvents = [
-    'click',
-    'dblclick',
-    'mousedown',
-    'mouseup',
-    'mouseover',
-    'mouseout',
-    'contextmenu'
-];
-export const keyboardEvents = ['keypress', 'keydown', 'keyup'];
-export const locationEvents = ['locationfound', 'locationerror'];
-export const leafletMouseEvents = [...interactiveLayerEvents, 'mousemove', 'preclick'];
-export const layerEvents = ['add', 'remove'];
-export const popupEvents = ['popupopen', 'popupclose'];
-export const tooltipEvents = ['tooltipopen', 'tooltipclose'];
-export const layerGroupEvents = ['layeradd', 'layerremove'];
-export const layersControlEvents = ['baselayerchange', 'overlayadd', 'overlayremove'];
-const leafletEvents = [
-    'load',
-    'move',
-    'moveend',
-    'movestart',
-    'unload',
-    'viewreset',
-    'zoom',
-    'zoomend',
-    'zoomlevelschange',
-    'zoomstart'
-];
-export const mapStateChangeEvents = [...leafletEvents, 'resize'];

package/dist/map.svelte.d.ts

@@ -0,0 +1,10 @@
+import type { Map as LeafletMap, MapOptions } from 'leaflet';
+import { type CreateSvelteEventsMap } from './utils.js';
+export declare function updateMapProps(instance: LeafletMap, newProps: MapOptions): void;
+export declare const mapEvents: readonly ["keypress", "keydown", "keyup", "layeradd", "layerremove", "baselayerchange", "overlayadd", "overlayremove", "click", "dblclick", "mousedown", "mouseup", "mouseover", "mouseout", "contextmenu", "mousemove", "preclick", "locationfound", "locationerror", "load", "move", "moveend", "movestart", "unload", "viewreset", "zoom", "zoomend", "zoomlevelschange", "zoomstart", "resize", "popupopen", "popupclose", "tooltipopen", "tooltipclose", "autopanstart", "zoomanim"];
+export type MapEvents = CreateSvelteEventsMap<typeof mapEvents, LeafletMap>;
+declare module 'leaflet' {
+    interface Handler {
+        _setPanDelta(delta: number): void;
+    }
+}

package/dist/map.svelte.js

@@ -0,0 +1,117 @@
+import { capitalize } from './utils.js';
+import { keyboardEvents, layerGroupEvents, layersControlEvents, leafletMouseEvents, locationEvents, mapStateChangeEvents, popupSpecificEvents, tooltipEvents, } from './events.js';
+// stores the function bound to the event listener so it can be removed later
+let boundInvalidateMapSize = null;
+function invalidateMapSize(map) {
+    map.invalidateSize({
+        // TODO : add a way to customize these default values
+        debounceMoveend: true,
+        pan: true,
+    });
+}
+export function updateMapProps(instance, newProps) {
+    if (!newProps)
+        return;
+    // any is the default type for the Object.entries values anyway
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    for (const [key, value] of Object.entries(newProps)) {
+        // skip if the option value is unchanged
+        if (instance.options[key] === value)
+            continue;
+        // update the option value :
+        // - needed for future comparison (CF above)
+        // - handles simple cases :
+        //		untested :
+        //		  closePopupOnClick	markerZoomAnimation	tapTolerance	worldCopyJump(untested)
+        //		tested :
+        //		  bounceAtZoomLimits	preferCanvas
+        //		  easeLinearity				transform3DLimit
+        //		  inertia							wheelDebounceTime
+        //		  inertiaDeceleration	zoomAnimationThreshold
+        //		  inertiaMaxSpeed			zoomDelta
+        //		  maxBoundsViscosity	zoomSnap
+        instance.options[key] = value;
+        switch (key) {
+            // TODO : move check of unsupported options before the unchanged check
+            case 'fadeAnimation':
+            case 'zoomAnimation':
+            case 'wheelPxPerZoomLevel':
+            case 'crs':
+            case 'layers':
+            case 'renderer':
+                // animations could be hacked around by changing style attributes
+                // not a priority
+                throw new Error(`mutation of ${key} option is not supported`);
+            // setters cases
+            case 'maxBounds':
+            case 'minZoom':
+            case 'maxZoom':
+            case 'zoom': {
+                const setterName = `set${capitalize(key)}`;
+                const setter = instance[setterName].bind(instance);
+                setter(value);
+                break;
+            }
+            // enable/disable cases (Handlers)
+            case 'boxZoom':
+            case 'scrollWheelZoom':
+            case 'doubleClickZoom':
+            case 'dragging':
+            case 'keyboard':
+            case 'tapHold':
+            case 'touchZoom': // untested
+                if (value)
+                    instance[key]?.enable();
+                else
+                    instance[key]?.disable();
+                break;
+            // Control cases
+            case 'zoomControl':
+                if (value) {
+                    instance.zoomControl = instance.zoomControl || window.L.control.zoom();
+                    instance.zoomControl.addTo(instance);
+                }
+                else
+                    instance.zoomControl?.remove();
+                break;
+            case 'attributionControl':
+                if (value) {
+                    instance.attributionControl =
+                        instance.attributionControl || window.L.control.attribution();
+                    instance.attributionControl.addTo(instance);
+                }
+                else
+                    instance.attributionControl?.remove();
+                break;
+            //complex cases
+            case 'center':
+                instance.setView(value, instance.getZoom());
+                break;
+            case 'keyboardPanDelta':
+                // seems fine despite using a private method
+                instance.keyboard._setPanDelta(value);
+                break;
+            case 'trackResize':
+                if (boundInvalidateMapSize === null)
+                    boundInvalidateMapSize = invalidateMapSize.bind(null, instance);
+                window.removeEventListener('resize', boundInvalidateMapSize);
+                if (value) {
+                    window.addEventListener('resize', boundInvalidateMapSize);
+                    invalidateMapSize(instance);
+                }
+                break;
+        }
+    }
+}
+export const mapEvents = [
+    ...keyboardEvents,
+    ...layerGroupEvents,
+    ...layersControlEvents,
+    ...leafletMouseEvents,
+    ...locationEvents,
+    ...mapStateChangeEvents,
+    ...popupSpecificEvents,
+    ...tooltipEvents,
+    'autopanstart',
+    'zoomanim',
+];

package/dist/marker.svelte.d.ts

@@ -0,0 +1,5 @@
+import type { Marker as LeafletMarker, MarkerOptions } from 'leaflet';
+import { type CreateSvelteEventsMap } from './utils.js';
+export declare function updateMarkerProps(instance: LeafletMarker, options: MarkerOptions): void;
+export declare const markerEvents: readonly ["move", "dragstart", "movestart", "drag", "dragend", "moveend", "click", "dblclick", "mousedown", "mouseup", "mouseover", "mouseout", "contextmenu", "add", "remove", "popupopen", "popupclose", "tooltipopen", "tooltipclose"];
+export type MarkerEvents = CreateSvelteEventsMap<typeof markerEvents, LeafletMarker>;

package/dist/marker.svelte.js

@@ -0,0 +1,61 @@
+import { capitalize } from './utils.js';
+import { draggingEvents, interactiveLayerEvents, layerEvents, popupSpecificEvents, tooltipEvents, } from './events.js';
+// const L = globalThis.window.L;
+export function updateMarkerProps(instance, options) {
+    if (!options)
+        return;
+    for (const [key, value] of Object.entries(options)) {
+        // skip if the option value is unchanged
+        if (instance.options[key] === value)
+            continue;
+        // update the option value :
+        // - needed for future comparison (CF above)
+        // - handles simple cases
+        //     bubblingMouseEvents	riseOffset	autoPanPadding
+        //     autoPanSpeed
+        instance.options[key] = value;
+        switch (key) {
+            // setter cases
+            case 'icon': // untested
+            case 'zIndexOffset':
+            case 'opacity': {
+                const setterName = `set${capitalize(key)}`;
+                const setter = instance[setterName].bind(instance);
+                setter(value);
+                break;
+            }
+            // complex cases
+            case 'title':
+                instance.getElement()?.setAttribute('title', value);
+                break;
+            case 'alt':
+                instance.getElement()?.setAttribute('alt', value);
+                break;
+            case 'draggable':
+                // option and handler are named differently
+                if (value)
+                    instance.dragging?.enable();
+                else
+                    instance.dragging?.disable();
+                break;
+            // TODO : move check of unsupported options before the unchanged check
+            case 'keyboard':
+            case 'riseOnHover':
+            case 'shadowPane':
+            case 'autoPan':
+            case 'autoPanOnFocus':
+            case 'interactive':
+            case 'pane':
+            case 'attribution':
+                throw new Error(`mutation of ${key} option is not supported`);
+        }
+    }
+}
+export const markerEvents = [
+    'move',
+    ...draggingEvents,
+    ...interactiveLayerEvents,
+    ...layerEvents,
+    ...popupSpecificEvents,
+    ...tooltipEvents,
+];

package/dist/markerClusterGroup.svelte.d.ts

@@ -0,0 +1,9 @@
+import { type MarkerEvents } from './marker.svelte.js';
+import type { CreateSvelteEventsMap } from './utils.js';
+type ClusterifyMarkerEvent<E> = E extends `on${infer N}` ? `oncluster${N}` : never;
+declare const clusterSpecificEvents: readonly ["animationend", "spiderfied", "unspiderfied"];
+export declare const markerClusterGroupEvents: readonly [...("clustermovestart" | "clustermove" | "clustermoveend" | "clusterdragstart" | "clusterdrag" | "clusteradd" | "clusterremove" | "clusterpopupopen" | "clusterpopupclose" | "clustertooltipopen" | "clustertooltipclose" | "clusterclick" | "clusterdblclick" | "clustermousedown" | "clustermouseup" | "clustermouseover" | "clustermouseout" | "clustercontextmenu" | "clusterdragend")[], "animationend", "spiderfied", "unspiderfied"];
+export type MarkerClusterGroupEvents = {
+    [K in keyof MarkerEvents as ClusterifyMarkerEvent<K>]: MarkerEvents[K];
+} & CreateSvelteEventsMap<typeof clusterSpecificEvents>;
+export {};

package/dist/markerClusterGroup.svelte.js

@@ -0,0 +1,7 @@
+import { markerEvents } from './marker.svelte.js';
+const clusteredMarkerEvents = markerEvents.map((event) => `cluster${event}`);
+const clusterSpecificEvents = ['animationend', 'spiderfied', 'unspiderfied'];
+export const markerClusterGroupEvents = [
+    ...clusteredMarkerEvents,
+    ...clusterSpecificEvents,
+];

package/dist/polygon.svelte.d.ts

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

package/dist/polygon.svelte.js

@@ -0,0 +1 @@
+"use strict";

package/dist/polyline.svelte.d.ts

@@ -0,0 +1,6 @@
+import type { CreateSvelteEventsMap } from './utils.js';
+import type { Polygon as LeafletPolygon, Polyline as LeafletPolyline, PolylineOptions } from 'leaflet';
+export declare function updatePolylineProps(instance: LeafletPolygon | LeafletPolyline, options: PolylineOptions): void;
+export declare const polygonEvents: readonly ["click", "dblclick", "mousedown", "mouseup", "mouseover", "mouseout", "contextmenu", "add", "remove", "popupopen", "popupclose", "tooltipopen", "tooltipclose"];
+export type PolygonEvents = CreateSvelteEventsMap<typeof polygonEvents, LeafletPolygon>;
+export type PolylineEvents = CreateSvelteEventsMap<typeof polygonEvents, LeafletPolyline>;

package/dist/polyline.svelte.js

@@ -0,0 +1,56 @@
+import { interactiveLayerEvents, layerEvents, popupSpecificEvents, tooltipEvents, } from './events.js';
+export function updatePolylineProps(instance, options) {
+    if (!options)
+        return;
+    for (const [key, value] of Object.entries(options)) {
+        // skip if the option value is unchanged
+        const oldValue = instance.options[key];
+        if (oldValue === value)
+            continue;
+        // update the option value :
+        // - needed for future comparison (CF above)
+        // - handles simple cases
+        //     bubblingMouseEvents	riseOffset	autoPanPadding
+        //     autoPanSpeed
+        instance.options[key] = value;
+        switch (key) {
+            case 'smoothFactor':
+            case 'noClip':
+            case 'renderer':
+            case 'interactive':
+            case 'bubblingMouseEvents':
+            case 'pane':
+            case 'attribution':
+                throw new Error(`mutation of ${key} option is not supported`);
+            case 'className':
+                if (value === '')
+                    instance.getElement()?.classList.remove(oldValue);
+                else if (oldValue === '')
+                    instance.getElement()?.classList.add(value);
+                else
+                    instance.getElement()?.classList.replace(oldValue, value);
+                break;
+            // setStyle case
+            case 'stroke':
+            case 'color':
+            case 'weight':
+            case 'opacity':
+            case 'lineCap':
+            case 'lineJoin':
+            case 'dashArray':
+            case 'dashOffset':
+            case 'fill':
+            case 'fillColor':
+            case 'fillOpacity':
+            case 'fillRule':
+                instance.setStyle(options);
+                break;
+        }
+    }
+}
+export const polygonEvents = [
+    ...interactiveLayerEvents,
+    ...layerEvents,
+    ...popupSpecificEvents,
+    ...tooltipEvents,
+];