@nextgis/ngw-leaflet 1.5.0 → 1.8.0

package/lib/ngw-leaflet.esm-browser.js

@@ -1,4 +1,4 @@
-/** Bundle of @nextgis/ngw-leaflet; version: 1.5.0; author: NextGIS */
+/** Bundle of @nextgis/ngw-leaflet; version: 1.8.0; author: NextGIS */
 function styleInject(css, ref) {
   if ( ref === void 0 ) ref = {};
   var insertAt = ref.insertAt;
@@ -14721,7 +14721,6 @@ let ID$3 = 0;
  *
  * promise.cancel();
  * ```
- * @public
  */
 class CancelablePromise {
     constructor(executor, timeout) {
@@ -15024,8 +15023,7 @@ function debugLog(message) {
 }
 
 /**
- *
- * @param ev @deprecated
+ * @internal
  */
 function deprecatedMapClick(ev) {
     if (!ev.lngLat && ev.latLng) {
@@ -15037,6 +15035,7 @@ function deprecatedMapClick(ev) {
     return ev;
 }
 
+/** @internal */
 function deprecatedWarn(message) {
     console.warn(`DEPRECATED WARN: ${message}`);
 }
@@ -15213,8 +15212,8 @@ function objectRemoveEmpty(obj) {
     return newObj;
 }
 
-function reEscape(s) {
-    return s.replace(/[-/\\^$*+?.()|[\]{}]/g, '\\$&');
+function isObject$1(val) {
+    return Object.prototype.toString.call(val) === '[object Object]';
 }
 
 function fixUrlStr(url) {
@@ -15222,13 +15221,6 @@ function fixUrlStr(url) {
     return url.replace(/([^:]\/)\/+/g, '$1');
 }
 
-/**
- * @module utils
- */
-function isObject$1(val) {
-    return Object.prototype.toString.call(val) === '[object Object]';
-}
-
 function isExpression(value) {
     if (Array.isArray(value)) {
         return true;
@@ -15317,6 +15309,9 @@ function createExpressionCallback(paint) {
     return;
 }
 
+function reEscape(s) {
+    return s.replace(/[-/\\^$*+?.()|[\]{}]/g, '\\$&');
+}
 function like(b, a, iLike) {
     a = String(a);
     b = String(b);
@@ -15376,7 +15371,7 @@ function featureFilter(feature, filters) {
 function propertiesFilter(properties, filters) {
     const logic = typeof filters[0] === 'string' ? filters[0] : 'all';
     const filterFunction = (p) => {
-        if (checkIfPropertyFilter(p)) {
+        if (isPropertyFilter(p)) {
             const [field, operation, value] = p;
             const operationExec = operationsAliases[operation];
             if (operationExec) {
@@ -15767,7 +15762,7 @@ function clearObject(obj) {
 let ID$2 = 0;
 const OPTIONS$1 = {
     minZoom: 0,
-    maxZoom: 21,
+    maxZoom: 20,
     paint: {
         color: 'blue',
         opacity: 0.4,
@@ -15925,7 +15920,7 @@ class WebMapMain {
     }
     /**
      * Returns the map's geographical centerpoint.
-     * @return lngLat Array of two numbers representing longitude and latitude of the center of the map view.
+     * @returns lngLat Array of two numbers representing longitude and latitude of the center of the map view.
      *
      * @example
      * ```javascript
@@ -15958,7 +15953,7 @@ class WebMapMain {
     }
     /**
      * Returns the map's current zoom level.
-     * @return The map's current zoom level (0-24).
+     * @returns The map's current zoom level (0-24).
      */
     getZoom() {
         return this.mapAdapter.getZoom();
@@ -16293,8 +16288,10 @@ class WebMapLayers extends WebMapMain {
      */
     async fitLayer(layerDef, options) {
         const layer = this.getLayer(layerDef);
-        if (layer && layer.getExtent) {
-            const extent = await layer.getExtent();
+        // TODO: remove backward compatibility for `getExtent`
+        const getBounds = layer && (layer.getBounds || layer.getExtent);
+        if (getBounds) {
+            const extent = await getBounds.call(layer);
             if (extent) {
                 this.fitBounds(extent, options);
             }
@@ -16382,7 +16379,7 @@ class WebMapLayers extends WebMapMain {
         const layer = await this.addLayer(adapter, {
             ...options,
             baselayer: true,
-        });
+        }, undefined);
         return layer;
     }
     /**
@@ -16402,7 +16399,7 @@ class WebMapLayers extends WebMapMain {
     async addLayer(adapter, options = {}, order) {
         var _a, _b;
         const id = this._layersIdCounter++;
-        const _order = order !== undefined
+        const _order = defined(order)
             ? order
             : options.order !== undefined
                 ? options.order
@@ -16497,8 +16494,10 @@ class WebMapLayers extends WebMapMain {
             if (opacity !== undefined && opacity <= 1) {
                 this.setLayerOpacity(_adapter, opacity);
             }
-            if (options.fit && _adapter.getExtent) {
-                const extent = await _adapter.getExtent();
+            // TODO: remove backward compatibility for `getExtent`
+            const getBounds = layer && (_adapter.getBounds || _adapter.getExtent);
+            if (options.fit && getBounds) {
+                const extent = await getBounds.call(_adapter);
                 if (extent) {
                     await this.fitBounds(extent);
                 }
@@ -16621,10 +16620,18 @@ class WebMapLayers extends WebMapMain {
         opt.paint = opt.paint || {};
         return this.addLayer(adapter || 'GEOJSON', opt);
     }
-    /** Shortcut for {@link WebMapLayers.addGeoJsonLayer} to initialize adapter with generic types for working in typescript */
+    /** Shortcut for {@link WebMapLayers.addGeoJsonLayer} to create GeoJson adapter with generic types for working in typescript */
     addFeatureLayer(options = {}) {
         return this.addGeoJsonLayer(options);
     }
+    /** Shortcut for {@link WebMapLayers.addLayer} to create TileLayer adapter */
+    addTileLayer(url, options) {
+        return this.addLayer('TILE', { ...options, url });
+    }
+    /** Shortcut for {@link WebMapLayers.addLayer} to create TileLayer adapter */
+    addImageLayer(url, options) {
+        return this.addLayer('IMAGE', { ...options, url });
+    }
     /**
      * Show added layer on the map by it definition.
      */
@@ -16655,7 +16662,7 @@ class WebMapLayers extends WebMapMain {
         const onMap = layer && layer.options.visibility;
         const toStatus = status !== undefined ? status : !onMap;
         const silent = options.silent !== undefined ? options.silent : false;
-        const action = (l) => {
+        const action = async (l) => {
             const id = String(l.id);
             const preEventName = toStatus ? 'layer:preshow' : 'layer:prehide';
             const eventName = toStatus ? 'layer:show' : 'layer:hide';
@@ -16667,11 +16674,11 @@ class WebMapLayers extends WebMapMain {
                 const order = l.options.baselayer ? 0 : l.options.order;
                 // do not show baselayer if another on the map
                 if (l.options.baselayer && this._baselayers.length) {
-                    const anotherVisibleLayerBaseLayer = this._baselayers.find((x) => {
+                    const anotherVisibleBaselayers = this._baselayers.filter((x) => {
                         return x !== l.id && this.isLayerVisible(x);
                     });
-                    if (anotherVisibleLayerBaseLayer) {
-                        this.hideLayer(anotherVisibleLayerBaseLayer);
+                    for (const bl of anotherVisibleBaselayers) {
+                        await this.hideLayer(bl);
                     }
                 }
                 if (l.showLayer) {
@@ -17109,7 +17116,6 @@ function createToggleControl(createButtonControl, options) {
 
 /**
  * Collection of methods for managing map controls
- * @public
  */
 class WebMapControls extends WebMapLayers {
     constructor() {
@@ -17189,7 +17195,6 @@ class WebMapControls extends WebMapLayers {
      * webMap.addControl(toggleControl, 'top-right');
      * ```
      * {@link http://code.nextgis.com/demo-examples-toggle-control | Toggle button control example}
-     * @public
      */
     async createToggleControl(options) {
         await this.onLoad('build-map');
@@ -17206,7 +17211,6 @@ class WebMapControls extends WebMapLayers {
      *
      * @param control - Instance of WEB-GIS framework control.
      *                  What is returned by the {@Link WebMapControls.createControl | create} method
-     * @public
      */
     removeControl(control) {
         if ('remove' in control) {
@@ -17223,7 +17227,6 @@ class WebMapControls extends WebMapLayers {
      * Get instance of registered control
      * @param control - Any registered control string name
      * @param options - Custom control options
-     * @public
      */
     getControl(control, options) {
         const engine = this.mapAdapter.controlAdapters[control];
@@ -17351,7 +17354,6 @@ function setWebMap(id, webMap) {
  * @typeParam C - Control
  * @typeParam E - Events
  *
- * @public
  */
 class WebMap extends WebMapControls {
     constructor(mapOptions) {
@@ -17366,24 +17368,19 @@ class WebMap extends WebMapControls {
      * @internal
      */
     async _addLayerProviders() {
-        try {
-            for await (const kit of this._starterKits) {
-                if (kit.getLayerAdapters) {
-                    const adapters = await kit.getLayerAdapters.call(kit);
-                    if (adapters) {
-                        for await (const adapter of adapters) {
-                            const newAdapter = await adapter.createAdapter(this);
-                            if (newAdapter) {
-                                this.mapAdapter.layerAdapters[adapter.name] = newAdapter;
-                            }
+        for await (const kit of this._starterKits) {
+            if (kit.getLayerAdapters) {
+                const adapters = await kit.getLayerAdapters.call(kit);
+                if (adapters) {
+                    for await (const adapter of adapters) {
+                        const newAdapter = await adapter.createAdapter(this);
+                        if (newAdapter) {
+                            this.mapAdapter.layerAdapters[adapter.name] = newAdapter;
                         }
                     }
                 }
             }
         }
-        catch (er) {
-            throw new Error(er);
-        }
     }
     /**
      * @internal
@@ -18415,6 +18412,66 @@ function getLayerFilterOptions(options) {
     return filterOptions;
 }
 
+function getNgwWebmapExtent(webmap) {
+    const bottom = webmap['extent_bottom'];
+    const left = webmap['extent_left'];
+    const top = webmap['extent_top'];
+    const right = webmap['extent_right'];
+    if (bottom && left && top && right) {
+        const extent = [left, bottom, right, top];
+        if (extent[3] > 82) {
+            extent[3] = 82;
+        }
+        if (extent[1] < -82) {
+            extent[1] = -82;
+        }
+        return extent;
+    }
+}
+function fetchNgwLayerExtent({ resourceId, connector, cache = true, }) {
+    return connector
+        .get('layer.extent', { cache }, { id: resourceId })
+        .then((resp) => {
+        if (resp) {
+            const { maxLat, maxLon, minLat, minLon } = resp.extent;
+            const extentArray = [minLon, minLat, maxLon, maxLat];
+            return extentArray;
+        }
+    });
+}
+function fetchNgwLayerItemExtent({ resourceId, featureId, connector, cache = true, }) {
+    return connector
+        .get('feature_layer.feature.item_extent', { cache }, { id: resourceId, fid: featureId })
+        .then((resp) => {
+        if (resp) {
+            const { maxLat, maxLon, minLat, minLon } = resp.extent;
+            const extentArray = [minLon, minLat, maxLon, maxLat];
+            return extentArray;
+        }
+    });
+}
+function fetchNgwResourceExtent(item, connector) {
+    if (item.webmap) {
+        return CancelablePromise.resolve(getNgwWebmapExtent(item.webmap));
+    }
+    else {
+        const resource = item.resource;
+        if (resource.cls && resource.cls.indexOf('style') !== -1) {
+            return connector.getResource(resource.parent.id).then((res) => {
+                if (res) {
+                    return fetchNgwLayerExtent({
+                        resourceId: res.resource.id,
+                        connector,
+                    });
+                }
+            });
+        }
+        else {
+            return fetchNgwLayerExtent({ resourceId: resource.id, connector });
+        }
+    }
+}
+
 async function resourceIdFromLayerOptions(options, connector) {
     const resource = options.resource;
     const item = resource;
@@ -18653,55 +18710,6 @@ function fetchNgwLayerFeatureCollection(options) {
     });
 }
 
-function getNgwWebmapExtent(webmap) {
-    const bottom = webmap['extent_bottom'];
-    const left = webmap['extent_left'];
-    const top = webmap['extent_top'];
-    const right = webmap['extent_right'];
-    if (bottom && left && top && right) {
-        const extent = [left, bottom, right, top];
-        if (extent[3] > 82) {
-            extent[3] = 82;
-        }
-        if (extent[1] < -82) {
-            extent[1] = -82;
-        }
-        return extent;
-    }
-}
-function fetchNgwLayerExtent({ resourceId, connector, cache = true, }) {
-    return connector
-        .get('layer.extent', { cache }, { id: resourceId })
-        .then((resp) => {
-        if (resp) {
-            const { maxLat, maxLon, minLat, minLon } = resp.extent;
-            const extentArray = [minLon, minLat, maxLon, maxLat];
-            return extentArray;
-        }
-    });
-}
-function fetchNgwResourceExtent(item, connector) {
-    if (item.webmap) {
-        return CancelablePromise.resolve(getNgwWebmapExtent(item.webmap));
-    }
-    else {
-        const resource = item.resource;
-        if (resource.cls && resource.cls.indexOf('style') !== -1) {
-            return connector.getResource(resource.parent.id).then((res) => {
-                if (res) {
-                    return fetchNgwLayerExtent({
-                        resourceId: res.resource.id,
-                        connector,
-                    });
-                }
-            });
-        }
-        else {
-            return fetchNgwLayerExtent({ resourceId: resource.id, connector });
-        }
-    }
-}
-
 async function createGeoJsonAdapter(props) {
     var _a, _b;
     const { item, webMap, Adapter, connector, layerOptions, addLayerOptionsPriority: alop, } = props;
@@ -18790,14 +18798,18 @@ async function createGeoJsonAdapter(props) {
             }
             return layer;
         }
+        /** @deprecated use {@link NgwGeoJsonAdapter.getBounds} instead */
         getExtent() {
+            return this.getBounds();
+        }
+        async getBounds() {
             const hasData = this.getLayers && this.getLayers().length;
             if (this.options.strategy === 'BBOX' || hasData) {
                 return fetchNgwResourceExtent(item, connector);
             }
             else {
-                if (super.getExtent) {
-                    return super.getExtent();
+                if (super.getBounds) {
+                    return super.getBounds();
                 }
             }
         }
@@ -18847,7 +18859,7 @@ async function createGeoJsonAdapter(props) {
                 this.emitter.emit('updated');
             }
             catch (er) {
-                if (er.name !== 'CancelError') {
+                if (er instanceof Error && er.name !== 'CancelError') {
                     throw er;
                 }
             }
@@ -18931,10 +18943,10 @@ async function createGeoJsonAdapter(props) {
     return NgwGeoJsonAdapter;
 }
 
-function getLayerAdapterOptions(options, webMap, baseUrl) {
+function ngwApiToAdapterOptions({ options, webMap, baseUrl, }) {
     let adapter = options.adapter || 'IMAGE';
     let url;
-    const layerAdapters = webMap.getLayerAdapters();
+    const layerAdapters = webMap && webMap.getLayerAdapters();
     const isImageAllowed = layerAdapters ? layerAdapters.IMAGE : true;
     const resourceId = options.resource;
     const nd = options.tileNoData ? options.tileNoData : 200;
@@ -19024,10 +19036,10 @@ async function createRasterAdapter({ layerOptions, webMap, connector, item, }) {
             adapter = 'TILE';
         }
     }
-    const adapterClass = webMap.mapAdapter.layerAdapters[adapter];
-    if (adapterClass) {
+    const AdapterClass = webMap.mapAdapter.layerAdapters[adapter];
+    if (AdapterClass) {
         const resourceId = await resourceIdFromLayerOptions(layerOptions, connector);
-        return class Adapter extends adapterClass {
+        return class RasterAdapter extends AdapterClass {
             constructor(map, _options) {
                 var _a;
                 super(map, _options);
@@ -19035,7 +19047,11 @@ async function createRasterAdapter({ layerOptions, webMap, connector, item, }) {
                 // options = {};
                 this.item = item;
                 this.resourceId = resourceId;
-                const opt = getLayerAdapterOptions(layerOptions, webMap, connector.options.baseUrl || '');
+                const opt = ngwApiToAdapterOptions({
+                    options: layerOptions,
+                    webMap,
+                    baseUrl: connector.options.baseUrl || '',
+                });
                 if (opt) {
                     const layerAdapterOptions = {
                         ...opt,
@@ -19750,12 +19766,13 @@ NgwWebmapItem.options = {
     ],
 };
 
-async function createOnFirstShowNgwAdapter({ webMap, connector, item, adapterOptions = {}, idPrefix = 'basemapwebmap', }) {
+async function createOnFirstShowAdapter({ webMap, adapterOptions = {}, onLayerAdded, createAdapter, }) {
     class OnFirstShowAdapter {
         constructor() {
             this.options = {};
             this.layer = [];
             this._removed = false;
+            this._creatingInProgress = false;
         }
         addLayer() {
             return this.layer;
@@ -19764,6 +19781,9 @@ async function createOnFirstShowNgwAdapter({ webMap, connector, item, adapterOpt
             this._removed = true;
             this.layer.forEach((x) => webMap.removeLayer(x));
         }
+        destroyed() {
+            return this._removed;
+        }
         showLayer() {
             this.options.visibility = true;
             if (this.layer.length) {
@@ -19772,34 +19792,38 @@ async function createOnFirstShowNgwAdapter({ webMap, connector, item, adapterOpt
                 });
             }
             else {
-                createAsyncAdapter({
-                    resource: item.resource_id,
-                    adapterOptions: {
-                        name: item.display_name,
-                        opacity: item.opacity,
-                    },
-                }, webMap, connector).then((Adapter) => {
-                    if (Adapter) {
-                        const adapter = new Adapter(webMap.mapAdapter.map, {
-                            ...adapterOptions,
-                            baselayer: false,
-                        });
-                        adapter.addLayer({}).then((baselayer) => {
-                            adapter.options.baselayer = false;
-                            Object.assign(adapter.options, adapterOptions);
-                            adapter.id = idPrefix + '-' + item.resource_id;
-                            adapter.layer = baselayer;
-                            if (this._removed) {
-                                webMap.removeLayer(adapter);
-                            }
-                            if (this.options.visibility) {
-                                webMap.showLayer(adapter);
-                            }
-                            this.layer.push(adapter);
-                        });
+                this.loadLayer();
+            }
+        }
+        async loadLayer() {
+            if (!this.layer.length && !this._creatingInProgress) {
+                this._creatingInProgress = true;
+                const Adapter = await createAdapter(this);
+                if (Adapter) {
+                    const adapter = new Adapter(webMap.mapAdapter.map, {
+                        ...adapterOptions,
+                    });
+                    const realLayer = await adapter.addLayer({
+                        order: this.options.order,
+                        headers: this.options.headers,
+                        baselayer: this.options.baselayer,
+                    });
+                    if (onLayerAdded) {
+                        onLayerAdded(adapter);
                     }
-                });
+                    Object.assign(adapter.options, adapterOptions);
+                    adapter.layer = realLayer;
+                    if (this._removed) {
+                        webMap.removeLayer(adapter);
+                    }
+                    if (this.options.visibility) {
+                        await webMap.showLayer(adapter);
+                    }
+                    this.layer.push(adapter);
+                    this._creatingInProgress = false;
+                }
             }
+            return this.layer;
         }
         hideLayer() {
             this.options.visibility = false;
@@ -19811,6 +19835,29 @@ async function createOnFirstShowNgwAdapter({ webMap, connector, item, adapterOpt
     return OnFirstShowAdapter;
 }
 
+async function createOnFirstShowNgwAdapter({ webMap, connector, item, adapterOptions = {}, idPrefix = 'first-show-adapter', }) {
+    const createAdapter = () => {
+        return createAsyncAdapter({
+            resource: item.resource_id,
+            adapterOptions: {
+                name: item.display_name,
+                opacity: item.opacity,
+            },
+        }, webMap, connector);
+    };
+    const onLayerAdded = (adapter) => {
+        adapter.options.baselayer = false;
+        adapter.id = idPrefix + '-' + item.resource_id;
+    };
+    const OnFirstNgwShowAdapter = createOnFirstShowAdapter({
+        webMap,
+        adapterOptions,
+        onLayerAdded,
+        createAdapter,
+    });
+    return OnFirstNgwShowAdapter;
+}
+
 class BookmarkItem {
     constructor(options) {
         this.options = options;
@@ -19912,7 +19959,11 @@ class NgwWebmapLayerAdapter {
             this.layer.properties.property('visibility').set(false);
         }
     }
+    /** @deprecated use {@link NgwWebmapLayerAdapter.getBounds} instead */
     getExtent() {
+        return this.getBounds();
+    }
+    getBounds() {
         const webmap = this.response && this.response.webmap;
         if (webmap) {
             return getNgwWebmapExtent(webmap);
@@ -20044,6 +20095,7 @@ class NgwWebmapLayerAdapter {
                 // to avoid set many basemaps on init
                 const visibility = enabledAlreadySet ? false : x.enabled;
                 webMap.addBaseLayer(adapter, {
+                    id: WEBMAP_BASELAYER_ID_PREFIX + x.resource_id,
                     name: x.display_name,
                     opacity: x.opacity,
                     visibility,
@@ -20072,10 +20124,14 @@ class NgwWebmapLayerAdapter {
                 item.resourceId = resourceId;
                 item.updateWmsParams = (params) => updateImageParams(params, resourceId);
                 const adapter = item.layer_adapter.toUpperCase();
-                const layerAdapterOptions = getLayerAdapterOptions({
-                    adapter,
-                    resource: resourceId,
-                }, webMap, this.options.connector.options.baseUrl || '');
+                const layerAdapterOptions = ngwApiToAdapterOptions({
+                    options: {
+                        adapter,
+                        resource: resourceId,
+                    },
+                    webMap,
+                    baseUrl: this.options.connector.options.baseUrl || '',
+                });
                 item = {
                     ...item,
                     ...layerAdapterOptions,
@@ -20125,12 +20181,16 @@ async function createWebMapAdapter({ layerOptions: options, webMap, connector, }
 }
 
 class NgwResource {
+    /** @deprecated use {@link NgwResource.getBounds} instead */
     async getExtent() {
+        return this.getBounds();
+    }
+    async getBounds() {
         if (this._extent) {
             return this._extent;
         }
         if (this.item) {
-            this._extent = await fetchNgwResourceExtent(this.item, this.connector).then();
+            this._extent = await fetchNgwResourceExtent(this.item, this.connector);
             return this._extent;
         }
     }
@@ -20450,7 +20510,7 @@ const vectorLayerGeomToPaintTypeAlias = {
     MULTILINESTRINGZ: 'line',
     MULTIPOLYGONZ: 'polygon',
 };
-function addNgwLayer(options, webMap, connector) {
+function createNgwLayerAdapter(options, webMap, connector) {
     const headers = connector.getAuthorizationHeaders();
     if (headers) {
         options.headers = headers;
@@ -20566,14 +20626,14 @@ class IdentifyItem {
     constructor(options) {
         const f = options.feature;
         this.id = f.id;
+        this.geom = f.geom;
         this.label = f.label;
-        this.layerId = f.layerId;
         this.parent = f.parent;
         this.fields = f.fields;
-        this.geom = f.geom;
+        this.layerId = f.layerId;
         this.connector = options.connector;
     }
-    identify() {
+    identify(options = {}) {
         if (this._item) {
             return CancelablePromise.resolve(this._item);
         }
@@ -20583,6 +20643,7 @@ class IdentifyItem {
             resourceId: this.layerId,
             fields: null,
             extensions: ['attachment', 'description'],
+            ...options,
         }).then((resp) => {
             this._item = resp;
             this.geom = resp.geom;
@@ -20599,6 +20660,16 @@ class IdentifyItem {
             return this._resource.feature_layer;
         });
     }
+    getBounds() {
+        if (this._extent) {
+            return CancelablePromise.resolve(this._extent);
+        }
+        return fetchNgwLayerItemExtent({
+            connector: this.connector,
+            featureId: this.id,
+            resourceId: this.layerId,
+        });
+    }
     geojson() {
         if (this._geojson) {
             return CancelablePromise.resolve(this._geojson);
@@ -20612,6 +20683,8 @@ class IdentifyItem {
     }
 }
 
+const WEBMAP_BASELAYER_ID_PREFIX = 'webmap-baselayer';
+
 function fetchNgwLayerItem(options) {
     const params = {
         ...FEATURE_REQUEST_PARAMS,
@@ -20940,6 +21013,14 @@ function prepareWebMapOptions(options) {
     return options;
 }
 
+function getIdentifyRadius(center, zoom, pixelRadius) {
+    pixelRadius = pixelRadius !== null && pixelRadius !== void 0 ? pixelRadius : 10;
+    const metresPerPixel = (40075016.686 * Math.abs(Math.cos((center[1] * 180) / Math.PI))) /
+        Math.pow(2, zoom + 8);
+    const radius = pixelRadius * metresPerPixel * 0.0005;
+    return radius;
+}
+
 /**
  * Base class containing the logic of interaction WebMap with NextGIS services.
  *
@@ -20958,7 +21039,6 @@ function prepareWebMapOptions(options) {
  *   webmapId: 3985
  * });
  * ```
- * @public
  */
 class NgwMap extends WebMap {
     constructor(options) {
@@ -21035,7 +21115,7 @@ class NgwMap extends WebMap {
                         options.adapterOptions.setViewDelay = this.options.setViewDelay;
                     }
                 }
-                const adapter = addNgwLayer(options, this, this.connector);
+                const adapter = createNgwLayerAdapter(options, this, this.connector);
                 const adapterOpts = {
                     visibility: true,
                     // TODO: do not merge options, use only `adapterOptions`
@@ -21182,10 +21262,10 @@ class NgwMap extends WebMap {
         }
         const ngwLayer = id && this._ngwLayers[id];
         if (ngwLayer) {
-            if (ngwLayer.layer.getExtent) {
-                const extent = await ngwLayer.layer.getExtent();
-                if (extent) {
-                    this.fitBounds(extent, options);
+            if (ngwLayer.layer.getBounds) {
+                const bounds = await ngwLayer.layer.getBounds();
+                if (bounds) {
+                    this.fitBounds(bounds, options);
                 }
             }
             else {
@@ -21316,10 +21396,10 @@ class NgwMap extends WebMap {
     async _createWebMap() {
         await this.create();
         if (this.options.qmsId) {
-            this.addQmsBaseLayer();
+            this._addQmsBaseLayer();
         }
         if (this.options.osm) {
-            this.addOsmBaseLayer();
+            this._addOsmBaseLayer();
         }
         const resources = [];
         const layerFitAllowed = this._isFitFromResource();
@@ -21348,10 +21428,10 @@ class NgwMap extends WebMap {
         this._emitStatusEvent('ngw-map:create', this);
         this.enableSelection();
     }
-    addOsmBaseLayer() {
+    _addOsmBaseLayer() {
         this.addBaseLayer('OSM');
     }
-    addQmsBaseLayer() {
+    _addQmsBaseLayer() {
         let qmsId;
         let qmsLayerName;
         if (Array.isArray(this.options.qmsId)) {
@@ -21441,9 +21521,7 @@ class NgwMap extends WebMap {
             this._emitStatusEvent('ngw:select', null);
             return;
         }
-        const metresPerPixel = (40075016.686 * Math.abs(Math.cos((center[1] * 180) / Math.PI))) /
-            Math.pow(2, zoom + 8);
-        const radius = pixelRadius * metresPerPixel * 0.0005;
+        const radius = getIdentifyRadius(center, zoom, pixelRadius);
         const selectPromise = sendIdentifyRequest(ev, {
             layers: ids,
             connector: this.connector,
@@ -21486,79 +21564,6 @@ class NgwMap extends WebMap {
 }
 NgwMap.getIcon = getIcon;
 
-const typeAlias = {
-    Point: 'point',
-    LineString: 'line',
-    MultiPoint: 'point',
-    Polygon: 'polygon',
-    MultiLineString: 'line',
-    MultiPolygon: 'polygon',
-    GeometryCollection: 'polygon',
-};
-const PAINT = {
-    stroke: false,
-    opacity: 1,
-};
-const backAliases = {};
-for (const a in typeAlias) {
-    const layerType = typeAlias[a];
-    const backAlias = backAliases[layerType] || [];
-    backAlias.push(a);
-    backAliases[layerType] = backAlias;
-}
-function findMostFrequentGeomType(arr) {
-    const counts = {};
-    for (let fry = 0; fry < arr.length; fry++) {
-        counts[arr[fry]] = 1 + (counts[arr[fry]] || 0);
-    }
-    let maxName = '';
-    for (const c in counts) {
-        const maxCount = maxName ? counts[maxName] : 0;
-        if (counts[c] > maxCount) {
-            maxName = c;
-        }
-    }
-    return maxName;
-}
-function detectType(geojson) {
-    let geometry;
-    if (geojson.type === 'FeatureCollection') {
-        const featuresTypes = geojson.features.map((f) => f.geometry.type);
-        geometry = findMostFrequentGeomType(featuresTypes);
-    }
-    else if (geojson.type === 'GeometryCollection') {
-        const geometryTypes = geojson.geometries.map((g) => g.type);
-        geometry = findMostFrequentGeomType(geometryTypes);
-    }
-    else if (geojson.type === 'Feature') {
-        geometry = geojson.geometry.type;
-    }
-    else {
-        geometry = geojson.type;
-    }
-    return geometry;
-}
-function geometryFilter(geometry, type) {
-    const geoJsonGeometry = backAliases[type] || [];
-    return geoJsonGeometry.indexOf(geometry) !== -1;
-}
-function filterGeometries(data, type) {
-    if (data.type === 'FeatureCollection') {
-        const _data = data;
-        _data.features = _data.features.filter((f) => geometryFilter(f.geometry.type, type));
-    }
-    else if (data.type === 'Feature') {
-        const allow = geometryFilter(data.geometry.type, type);
-        if (!allow) {
-            return false;
-        }
-    }
-    else if (data.type === 'GeometryCollection') {
-        const _data = data;
-        _data.geometries = _data.geometries.filter((g) => geometryFilter(g.type, type));
-    }
-    return data;
-}
 function convertMapClickEvent(evt) {
     const coord = evt.containerPoint;
     const latLng = evt.latlng;
@@ -21655,6 +21660,119 @@ class AttributionControl extends leafletSrc.exports.Control.Attribution {
     }
 }
 
+function boundsToArray(bounds) {
+    const ne = bounds.getNorthEast();
+    const sw = bounds.getSouthWest();
+    return [sw.lng, sw.lat, ne.lng, ne.lat];
+}
+
+const typeAlias = {
+    Point: 'point',
+    LineString: 'line',
+    MultiPoint: 'point',
+    Polygon: 'polygon',
+    MultiLineString: 'line',
+    MultiPolygon: 'polygon',
+    GeometryCollection: 'polygon',
+};
+const PAINT = {
+    stroke: false,
+    opacity: 1,
+};
+const backAliases = {};
+for (const a in typeAlias) {
+    const layerType = typeAlias[a];
+    const backAlias = backAliases[layerType] || [];
+    backAlias.push(a);
+    backAliases[layerType] = backAlias;
+}
+function geometryFilter(geometry, type) {
+    const geoJsonGeometry = backAliases[type] || [];
+    return geoJsonGeometry.indexOf(geometry) !== -1;
+}
+function filterGeometries(data, type) {
+    if (data.type === 'FeatureCollection') {
+        const _data = data;
+        _data.features = _data.features.filter((f) => geometryFilter(f.geometry.type, type));
+    }
+    else if (data.type === 'Feature') {
+        const allow = geometryFilter(data.geometry.type, type);
+        if (!allow) {
+            return false;
+        }
+    }
+    else if (data.type === 'GeometryCollection') {
+        const _data = data;
+        _data.geometries = _data.geometries.filter((g) => geometryFilter(g.type, type));
+    }
+    return data;
+}
+function featuresBounds(features) {
+    const geoJsonLayer = new leafletSrc.exports.GeoJSON();
+    const features_ = Array.isArray(features) ? features : [features];
+    features_.forEach((f) => geoJsonLayer.addData(f));
+    return geoJsonLayer.getBounds();
+}
+function getFeaturesBounds(features) {
+    return boundsToArray(featuresBounds(features));
+}
+function getFeaturesCenter(features) {
+    const { lat, lng } = featuresBounds(features).getCenter();
+    return [lng, lat];
+}
+function createFeaturePositionOptions(features) {
+    return {
+        getBounds: () => getFeaturesBounds(features),
+        getCenter: () => getFeaturesCenter(features),
+    };
+}
+
+function createMouseEvent({ layer, source, }) {
+    const layer_ = source.target;
+    const feature = layer_.feature;
+    const opt = {
+        layer,
+        feature,
+        event: convertMapClickEvent(source),
+        source,
+        ...createFeaturePositionOptions(feature),
+    };
+    return opt;
+}
+
+function findMostFrequentGeomType(arr) {
+    const counts = {};
+    for (let fry = 0; fry < arr.length; fry++) {
+        counts[arr[fry]] = 1 + (counts[arr[fry]] || 0);
+    }
+    let maxName = '';
+    for (const c in counts) {
+        const maxCount = maxName ? counts[maxName] : 0;
+        if (counts[c] > maxCount) {
+            maxName = c;
+        }
+    }
+    return maxName;
+}
+function detectType(geojson) {
+    let geometry;
+    if (geojson.type === 'FeatureCollection') {
+        const featuresTypes = geojson.features.map((f) => f.geometry.type);
+        geometry = findMostFrequentGeomType(featuresTypes);
+    }
+    else if (geojson.type === 'GeometryCollection') {
+        const geometryTypes = geojson.geometries.map((g) => g.type);
+        geometry = findMostFrequentGeomType(geometryTypes);
+    }
+    else if (geojson.type === 'Feature') {
+        geometry = geojson.geometry.type;
+    }
+    else {
+        geometry = geojson.type;
+    }
+    return geometry;
+}
+
 class BaseAdapter {
     constructor(map, options) {
         this.map = map;
@@ -21670,7 +21788,8 @@ class BaseAdapter {
             this.pane = pane;
         }
     }
-    addLayer(_options) {
+    addLayer(options) {
+        Object.assign(this.options, options);
         return undefined;
     }
 }
@@ -21689,11 +21808,14 @@ class GeoJsonAdapter extends BaseAdapter {
         this.$unselect = () => {
             this.unselect();
         };
-        this.layer = new leafletSrc.exports.FeatureGroup([], { pane: this.pane });
     }
     addLayer(options) {
-        this.options = options;
+        Object.assign(this.options, options);
         this.paint = options.paint;
+        this.layer = new leafletSrc.exports.FeatureGroup([], {
+            ...options.nativeOptions,
+            pane: this.pane,
+        });
         this.selectedPaint = options.selectedPaint;
         options.paint = this.paint;
         if (options.data) {
@@ -21739,7 +21861,12 @@ class GeoJsonAdapter extends BaseAdapter {
     }
     getSelected() {
         return this._selectedLayers.map((x) => {
-            return { feature: x.feature, layer: x };
+            return {
+                target: this,
+                feature: x.feature,
+                layer: x,
+                ...createFeaturePositionOptions(x.feature),
+            };
         });
     }
     getFiltered() {
@@ -21748,27 +21875,37 @@ class GeoJsonAdapter extends BaseAdapter {
     filter(fun) {
         // Some optimization
         this._filterFun = fun;
-        // @ts-ignore
-        const _map = this.layer._map;
-        if (_map) {
-            this.layer.remove();
-        }
-        const filteredLayers = [];
-        this._layers.forEach(({ feature, layer }) => {
-            if (layer) {
-                const ok = fun ? fun({ feature, layer }) : true;
-                if (ok) {
-                    this.layer.addLayer(layer);
-                    filteredLayers.push({ feature, layer });
-                }
-                else {
-                    this.layer.removeLayer(layer);
+        const layer_ = this.layer;
+        const map = layer_ && layer_._map;
+        if (layer_ && map) {
+            layer_.remove();
+            const filteredLayers = [];
+            this._layers.forEach(({ feature, layer }) => {
+                if (layer) {
+                    const ok = fun
+                        ? fun({
+                            target: this,
+                            feature,
+                            layer,
+                            ...createFeaturePositionOptions(feature),
+                        })
+                        : true;
+                    if (ok) {
+                        layer_.addLayer(layer);
+                        filteredLayers.push({
+                            target: this,
+                            feature,
+                            layer,
+                            ...createFeaturePositionOptions(feature),
+                        });
+                    }
+                    else {
+                        layer_.removeLayer(layer);
+                    }
                 }
-            }
-        });
-        this._filteredLayers = filteredLayers;
-        if (_map) {
-            this.layer.addTo(_map);
+            });
+            this._filteredLayers = filteredLayers;
+            layer_.addTo(map);
         }
         return this._filteredLayers;
     }
@@ -21783,29 +21920,33 @@ class GeoJsonAdapter extends BaseAdapter {
                 layer,
                 visible,
                 target: this,
+                ...createFeaturePositionOptions(feature),
             };
         });
     }
     clearLayer(cb) {
         this.unselect();
-        if (cb) {
-            for (let fry = this._layers.length; fry--;) {
-                const def = this._layers[fry];
-                if (def) {
-                    const { feature, layer } = def;
-                    if (feature && layer) {
-                        const exist = cb(feature);
-                        if (exist) {
-                            this.layer.removeLayer(layer);
-                            this._layers.splice(fry, 1);
+        const layer_ = this.layer;
+        if (layer_) {
+            if (cb) {
+                for (let fry = this._layers.length; fry--;) {
+                    const def = this._layers[fry];
+                    if (def) {
+                        const { feature, layer } = def;
+                        if (feature && layer) {
+                            const exist = cb(feature);
+                            if (exist) {
+                                layer_.removeLayer(layer);
+                                this._layers.splice(fry, 1);
+                            }
                         }
                     }
                 }
             }
-        }
-        else {
-            this.layer.clearLayers();
-            this._layers = [];
+            else {
+                layer_.clearLayers();
+                this._layers = [];
+            }
         }
     }
     setData(data) {
@@ -21862,12 +22003,14 @@ class GeoJsonAdapter extends BaseAdapter {
             this.getLayers().forEach((x) => this._updateTooltip({ feature: x.feature, layer: x.layer }));
         }
     }
+    /** @deprecated use {@link GeoJsonAdapter.getBounds} instead */
     getExtent() {
-        const bounds = this.layer.getBounds();
-        const ne = bounds.getNorthEast();
-        const sw = bounds.getSouthWest();
-        if (ne && sw) {
-            return [sw.lng, sw.lat, ne.lng, ne.lat];
+        return this.getBounds();
+    }
+    getBounds() {
+        if (this.layer) {
+            const bounds = this.layer.getBounds();
+            return boundsToArray(bounds);
         }
     }
     setOpacity(value) {
@@ -21937,6 +22080,7 @@ class GeoJsonAdapter extends BaseAdapter {
                 type,
                 close,
                 onClose,
+                ...createFeaturePositionOptions(feature),
             })
             : options.popupContent;
         if (content && layer) {
@@ -22082,25 +22226,38 @@ class GeoJsonAdapter extends BaseAdapter {
             lopt = this._createPaintOptions(paint, type);
         }
         lopt.onEachFeature = (feature, layer) => {
+            this._onEachFeature(feature, layer);
+        };
+        return lopt;
+    }
+    _onEachFeature(feature, layer) {
+        const layer_ = this.layer;
+        if (layer_) {
+            const def = {
+                target: this,
+                feature,
+                layer,
+                ...createFeaturePositionOptions(feature),
+            };
             // @ts-ignore
             layer.options.pane = this.pane;
-            this._layers.push({ feature, layer });
+            this._layers.push(def);
             let ok = true;
             if (this._filterFun) {
-                ok = this._filterFun({ feature, layer });
+                ok = this._filterFun(def);
             }
             if (ok) {
                 const { popup, popupOptions, selectable, interactive, selectOnHover } = this.options;
                 // @ts-ignore
                 layer.options.interactive = defined(interactive) ? interactive : true;
-                this.layer.addLayer(layer);
+                layer_.addLayer(layer);
                 if (selectable) {
                     if (selectOnHover) {
                         layer.on('mouseover', () => {
-                            this._selectLayer({ feature, layer }, 'hover');
+                            this._selectLayer(def, 'hover');
                         });
                         layer.on('mouseout', () => {
-                            this._unSelectLayer({ feature, layer });
+                            this._unSelectLayer(def);
                         });
                     }
                     else {
@@ -22109,24 +22266,19 @@ class GeoJsonAdapter extends BaseAdapter {
                 }
                 this._handleMouseEvents(layer);
                 if (popup) {
-                    this._openPopup({ layer, feature }, popupOptions, 'api');
+                    this._openPopup({
+                        target: this,
+                        layer,
+                        feature,
+                        ...createFeaturePositionOptions(feature),
+                    }, popupOptions, 'api');
                 }
                 this._updateTooltip({ layer, feature });
             }
-        };
-        return lopt;
+        }
     }
     _handleMouseEvents(layer) {
         const isSelected = (l) => this._selectedLayers.indexOf(l) !== -1;
-        const createMouseOptions = (e) => {
-            const layer_ = e.target;
-            return {
-                layer: this,
-                feature: layer_.feature,
-                event: convertMapClickEvent(e),
-                source: e,
-            };
-        };
         const { onClick, onLayerClick, onMouseOut, onMouseOver } = this.options;
         // TODO: remove backward compatibility for onLayerClick
         const onClick_ = onClick || onLayerClick;
@@ -22134,25 +22286,37 @@ class GeoJsonAdapter extends BaseAdapter {
             layer.on('click', (e) => {
                 onClick_({
                     selected: isSelected(e.target),
-                    ...createMouseOptions(e),
+                    ...this._createMouseEvent(e),
                 });
             }, this);
         }
         if (onMouseOut) {
             layer.on('mouseout', (e) => {
-                onMouseOut(createMouseOptions(e));
+                onMouseOut(this._createMouseEvent(e));
             }, this);
         }
         if (onMouseOver) {
             layer.on('mouseover', (e) => {
-                onMouseOver(createMouseOptions(e));
+                onMouseOver(this._createMouseEvent(e));
             }, this);
         }
     }
+    _createMouseEvent(source) {
+        return createMouseEvent({
+            layer: this,
+            source: source,
+        });
+    }
     _selectOnLayerClick(e) {
         leafletSrc.exports.DomEvent.stopPropagation(e);
         const layer = e.target;
-        const def = { layer, feature: layer.feature };
+        const feature = layer.feature;
+        const def = {
+            target: this,
+            layer,
+            feature,
+            ...createFeaturePositionOptions(feature),
+        };
         const isSelected = this._selectedLayers.find((x) => x.layer === layer);
         if (isSelected) {
             if (this.options && this.options.unselectOnSecondClick) {
@@ -22180,10 +22344,12 @@ class GeoJsonAdapter extends BaseAdapter {
             this._openPopup(def, popupOptions, type, latlng);
         }
         if (this.options.onSelect) {
+            const features = def.feature ? [def.feature] : [];
             this.options.onSelect({
                 type,
                 layer: this,
-                features: def.feature ? [def.feature] : [],
+                features,
+                ...createFeaturePositionOptions(features),
             });
         }
     }
@@ -22513,7 +22679,6 @@ class ImageLayer extends leafletSrc.exports.Layer {
     }
 }
 
-// @ts-ignore
 class ImageAdapter extends BaseAdapter {
     addLayer(options) {
         const url = options && options.url;
@@ -22525,10 +22690,11 @@ class ImageAdapter extends BaseAdapter {
                 headers: options.headers,
                 setViewDelay: options.setViewDelay,
                 /**
-                 * TODO: safe remove, use only options.params
+                 * TODO: safe remove, use only options.nativeOptions
                  */
                 ...options,
                 ...options.params,
+                ...options.nativeOptions,
             });
             if (updateWmsParamsFromOpt) {
                 const updateWmsParams = this.layer.updateWmsParams;
@@ -22647,33 +22813,33 @@ const WmsLayer = makeRemote(WmsLayerBase);
 
 class WmsAdapter extends BaseAdapter {
     addLayer(options) {
-        if (options) {
-            const { url, ...opt } = options;
-            if (url) {
-                const layerOptions = {
-                    pane: this.pane,
-                    attribution: opt.attribution,
-                    minZoom: opt.minZoom,
-                    maxZoom: opt.maxZoom,
-                    layers: options.layers,
-                    format: options.format,
-                };
-                let layer;
-                if (opt.headers) {
-                    layer = new WmsLayer(url, { ...layerOptions, headers: opt.headers });
-                }
-                else {
-                    layer = new leafletSrc.exports.TileLayer.WMS(url, layerOptions);
-                }
-                return layer;
+        Object.assign(this.options, options);
+        const { url, ...opt } = options;
+        if (url) {
+            const layerOptions = {
+                pane: this.pane,
+                attribution: opt.attribution,
+                minZoom: opt.minZoom,
+                maxZoom: opt.maxZoom,
+                layers: options.layers,
+                format: options.format,
+                ...options.nativeOptions,
+            };
+            let layer;
+            if (opt.headers) {
+                layer = new WmsLayer(url, { ...layerOptions, headers: opt.headers });
             }
+            else {
+                layer = new leafletSrc.exports.TileLayer.WMS(url, layerOptions);
+            }
+            return layer;
         }
     }
 }
 
 class OsmAdapter extends TileAdapter {
     addLayer(options) {
-        const url = options.url || 'https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png';
+        const url = 'https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png';
         return super.addLayer({
             name: 'OpenStreetMap',
             attribution: '&copy; <a href="https://www.openstreetmap.org/copyright">OpenStreetMap</a> contributors',
@@ -22972,3 +23138,4 @@ if (window && !window.NgwMap) {
 }
 
 export { NgwLeaflet as default };
+//# sourceMappingURL=ngw-leaflet.esm-browser.js.map