@nextgis/leaflet-map-adapter 1.8.1 → 1.9.0

package/lib/index.d.ts

@@ -20,6 +20,7 @@ import { Map as Map_2 } from 'leaflet';
 import type { MapAdapter } from '@nextgis/webmap';
 import type { MapControl } from '@nextgis/webmap';
 import type { MapOptions } from '@nextgis/webmap';
+import type { ViewOptions } from '@nextgis/webmap';
 
 declare class AttributionControl extends Control.Attribution {
     constructor(options: AttributionControlOptions & ControlOptions);
@@ -52,12 +53,13 @@ declare class LeafletMapAdapter implements MapAdapter<Map_2, any, Control> {
     getControlContainer(): HTMLElement;
     setCursor(cursor: string): void;
     setView(lngLat: LngLatArray, zoom?: number): void;
+    setView(options: ViewOptions): void;
     setCenter(lngLat: LngLatArray): void;
     getCenter(): LngLatArray | undefined;
     setZoom(zoom: number): void;
     getZoom(): number | undefined;
     getBounds(): LngLatBoundsArray | undefined;
-    fitBounds(e: LngLatBoundsArray, options?: FitOptions): void;
+    fitBounds(bounds: LngLatBoundsArray, options?: FitOptions): void;
     getLayerAdapter(name: string): Type<LayerAdapter<L.Map, any, any>>;
     createControl(control: MapControl, options: CreateControlOptions): L.Control;
     createButtonControl(options: ButtonControlOptions): L.Control;

package/lib/leaflet-map-adapter.esm-browser.js

@@ -1,4 +1,4 @@
-/** Bundle of @nextgis/leaflet-map-adapter; version: 1.8.1; author: NextGIS */
+/** Bundle of @nextgis/leaflet-map-adapter; version: 1.9.0; author: NextGIS */
 var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
 
 var events = {exports: {}};
@@ -15038,7 +15038,9 @@ class GeoJsonAdapter extends BaseAdapter {
     getBounds() {
         if (this.layer) {
             const bounds = this.layer.getBounds();
-            return boundsToArray(bounds);
+            if (bounds.isValid()) {
+                return boundsToArray(bounds);
+            }
         }
     }
     setOpacity(value) {
@@ -15085,7 +15087,7 @@ class GeoJsonAdapter extends BaseAdapter {
             }
         }
     }
-    async _openPopup(def, options = {}, type, latlng) {
+    async _openPopup(def, options = {}, type, latLng) {
         var _a, _b;
         const { feature, layer } = def;
         const { minWidth, autoPan, maxWidth, closeButton: closeButton_, } = { minWidth: 300, ...options };
@@ -15100,8 +15102,9 @@ class GeoJsonAdapter extends BaseAdapter {
                 this._removePopup(popup);
             }
         };
-        const content = options.createPopupContent
-            ? await options.createPopupContent({
+        let content;
+        if (options.createPopupContent) {
+            content = await options.createPopupContent({
                 layer,
                 feature,
                 target: this,
@@ -15109,17 +15112,24 @@ class GeoJsonAdapter extends BaseAdapter {
                 close,
                 onClose,
                 ...createFeaturePositionOptions(feature),
-            })
-            : options.popupContent;
+            });
+        }
+        else {
+            content = options.popupContent;
+        }
         if (content && layer) {
-            popup = layer.bindPopup(content, {
+            const popupOptions = {
                 minWidth,
                 autoPan,
-                maxWidth,
+                // maxWidth,
                 closeButton,
                 closeOnClick: false,
                 autoClose: false,
-            });
+            };
+            if (defined(maxWidth)) {
+                popupOptions.maxWidth = maxWidth;
+            }
+            popup = layer.bindPopup(content, popupOptions);
             const unselectOnClose = (_b = (_a = this.options.popupOptions) === null || _a === void 0 ? void 0 : _a.unselectOnClose) !== null && _b !== void 0 ? _b : true;
             if (unselectOnClose) {
                 const p = layer.getPopup();
@@ -15129,9 +15139,7 @@ class GeoJsonAdapter extends BaseAdapter {
                     }, this);
             }
             this._openedPopup.push([popup, _closeHandlers, def]);
-            setTimeout(() => {
-                popup.openPopup(latlng);
-            }, 0);
+            popup.openPopup(latLng);
         }
     }
     _removePopup(popup) {
@@ -15293,15 +15301,19 @@ class GeoJsonAdapter extends BaseAdapter {
                     }
                 }
                 this._handleMouseEvents(layer);
-                if (popup) {
-                    this._openPopup({
-                        target: this,
-                        layer,
-                        feature,
-                        ...createFeaturePositionOptions(feature),
-                    }, popupOptions, 'api');
-                }
-                this._updateTooltip({ layer, feature });
+                // The timeout is needed to display the popup immediately when adding a layer to the map.
+                // Without a timeout, the layer may not yet have a _map object
+                setTimeout(() => {
+                    if (popup) {
+                        this._openPopup({
+                            target: this,
+                            layer,
+                            feature,
+                            ...createFeaturePositionOptions(feature),
+                        }, popupOptions, 'api');
+                    }
+                    this._updateTooltip({ layer, feature });
+                });
             }
         }
     }
@@ -15877,6 +15889,15 @@ class OsmAdapter extends TileAdapter {
     }
 }
 
+function arrayToBoundsExpression(bounds) {
+    const e = bounds;
+    // top, left, bottom, right
+    return [
+        [e[3], e[0]],
+        [e[1], e[2]],
+    ];
+}
+
 class LeafletMapAdapter$1 {
     constructor() {
         this.options = { target: 'map' };
@@ -15900,10 +15921,7 @@ class LeafletMapAdapter$1 {
             this.map = new leafletSrc.exports.Map(this.options.target, {
                 attributionControl: false,
                 zoomControl: false,
-                maxBounds: mb && [
-                    [mb[1], mb[0]],
-                    [mb[3], mb[2]],
-                ],
+                maxBounds: mb ? arrayToBoundsExpression(mb) : undefined,
                 maxZoom,
                 minZoom,
                 center: center && [center[1], center[0]],
@@ -15940,14 +15958,52 @@ class LeafletMapAdapter$1 {
             this.map.getContainer().style.cursor = cursor;
         }
     }
-    setView(lngLat, zoom) {
-        const [lng, lat] = lngLat;
-        if (this.map) {
-            if (typeof zoom === 'number') {
-                this.map.setView([lat, lng], zoom, { animate: false });
+    setView(lngLatOrOpt, zoom) {
+        const map = this.map;
+        if (!map)
+            return;
+        if (Array.isArray(lngLatOrOpt)) {
+            const lngLat = lngLatOrOpt;
+            const [lng, lat] = lngLat;
+            if (this.map) {
+                if (typeof zoom === 'number') {
+                    this.map.setView([lat, lng], zoom, { animate: false });
+                }
+                else {
+                    this.setCenter([lng, lat]);
+                }
+            }
+        }
+        else {
+            const { zoom, center, maxBounds, bounds, minZoom, maxZoom } = lngLatOrOpt;
+            if (center && zoom !== undefined) {
+                this.setView(center, zoom);
             }
             else {
-                this.setCenter([lng, lat]);
+                if (zoom !== undefined) {
+                    this.setZoom(zoom);
+                }
+                if (center) {
+                    this.setCenter(center);
+                }
+            }
+            if (bounds) {
+                this.fitBounds(bounds);
+            }
+            if (maxBounds !== undefined) {
+                if (maxBounds) {
+                    map.setMaxBounds(arrayToBoundsExpression(maxBounds));
+                }
+                else {
+                    // @ts-ignore `null` works for unset maxBounds, but not in typing
+                    map.setMaxBounds(null);
+                }
+            }
+            if (maxZoom !== undefined) {
+                map.setMaxZoom(maxZoom);
+            }
+            if (minZoom !== undefined) {
+                map.setMinZoom(minZoom);
             }
         }
     }
@@ -15982,7 +16038,7 @@ class LeafletMapAdapter$1 {
         return [sw.lng, sw.lat, ne.lng, ne.lat];
     }
     // [west, south, east, north]
-    fitBounds(e, options = {}) {
+    fitBounds(bounds, options = {}) {
         if (this.map) {
             const { maxZoom, offset, padding } = options;
             const opt = {};
@@ -15995,11 +16051,7 @@ class LeafletMapAdapter$1 {
             if (offset) {
                 opt.padding = offset;
             }
-            // top, left, bottom, right
-            this.map.fitBounds([
-                [e[3], e[0]],
-                [e[1], e[2]],
-            ], opt);
+            this.map.fitBounds(arrayToBoundsExpression(bounds), opt);
         }
     }
     getLayerAdapter(name) {