@nextgis/ngw-map 1.16.9 → 1.18.0

package/lib/ngw-map.esm-bundler.js

@@ -1,829 +1,651 @@
-/** Bundle of @nextgis/ngw-map; version: 1.16.9; author: NextGIS */
+/** Bundle of @nextgis/ngw-map; version: 1.18.0; author: NextGIS */
 import { EventEmitter } from 'events';
 import CancelablePromise from '@nextgis/cancelable-promise';
-import { deepmerge, isObject, defined, deprecatedWarn, getIdentifyRadius } from '@nextgis/utils';
+import { deepmerge, deprecatedWarn, defined, isObject, getIdentifyRadius } from '@nextgis/utils';
 import { getDefaultControls, WebMap } from '@nextgis/webmap';
 export * from '@nextgis/webmap';
-import { NgwKit, fetchNgwLayerItem, fetchNgwLayerItems, fetchNgwLayerFeature, fetchNgwLayerFeatureCollection, fetchIdentifyItem, fetchIdentifyGeoJson, getIdentifyItems, createIdentifyItem, createNgwLayerAdapter, sendIdentifyRequest, getCompanyLogo, fetchNgwExtent } from '@nextgis/ngw-kit';
+import { NgwKit, createNgwLayerAdapter, fetchNgwLayerItem, fetchNgwLayerItems, fetchNgwLayerFeature, fetchNgwLayerFeatureCollection, fetchIdentifyItem, fetchIdentifyGeoJson, fetchNgwExtent, sendIdentifyRequest, getCompanyLogo, getIdentifyItems, createIdentifyItem } from '@nextgis/ngw-kit';
 import { getIcon } from '@nextgis/icons';
 import NgwConnector from '@nextgis/ngw-connector';
 import { QmsKit } from '@nextgis/qms-kit';
 
-/******************************************************************************
-Copyright (c) Microsoft Corporation.
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-PERFORMANCE OF THIS SOFTWARE.
-***************************************************************************** */
-/* global Reflect, Promise */
-
-var extendStatics = function(d, b) {
-    extendStatics = Object.setPrototypeOf ||
-        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-        function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-    return extendStatics(d, b);
-};
-
-function __extends(d, b) {
-    if (typeof b !== "function" && b !== null)
-        throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-    extendStatics(d, b);
-    function __() { this.constructor = d; }
-    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-}
-
-var __assign = function() {
-    __assign = Object.assign || function __assign(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-
-function __awaiter(thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-}
-
-function __generator(thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (_) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
+function appendNgwResources(options, resource, defOptions, overwriteOptions) {
+    if (typeof resource === 'number' || typeof resource === 'string') {
+        resource = Number(resource);
+        options.push({
+            ...defOptions,
+            resource,
+        });
+    }
+    else if (Array.isArray(resource)) {
+        const [resourceId, id] = resource;
+        options.push({
+            ...defOptions,
+            resource: resourceId,
+            id,
+            ...overwriteOptions,
+        });
+    }
+    else if (typeof resource === 'object') {
+        options.push({ ...defOptions, ...resource, ...overwriteOptions });
+    }
 }
 
-function appendNgwResources(options, resource, defOptions, overwriteOptions) {
-    if (typeof resource === 'number' || typeof resource === 'string') {
-        resource = Number(resource);
-        options.push(__assign(__assign({}, defOptions), { resource: resource }));
-    }
-    else if (Array.isArray(resource)) {
-        var resourceId = resource[0], id = resource[1];
-        options.push(__assign(__assign(__assign({}, defOptions), { resource: resourceId, id: id }), overwriteOptions));
-    }
-    else if (typeof resource === 'object') {
-        options.push(__assign(__assign(__assign({}, defOptions), resource), overwriteOptions));
-    }
+const OPTIONS = {
+    target: 'map',
+    baseUrl: '',
+    whitlabel: false,
+    controls: getDefaultControls(),
+    controlsOptions: {
+        ZOOM: { position: 'top-left' },
+        ATTRIBUTION: {
+            position: 'bottom-right',
+            customAttribution: [
+                '<a href="https://nextgis.com" target="_blank">©NextGIS</a>',
+            ],
+        },
+    },
+    pixelRadius: 10,
+};
+function prepareWebMapOptions(options) {
+    const kits = [new QmsKit()];
+    if (options.starterKits) {
+        options.starterKits.forEach((x) => {
+            kits.push(x);
+        });
+    }
+    if (!options.connector) {
+        options.connector = new NgwConnector({
+            baseUrl: options.baseUrl || '',
+            auth: options.auth,
+        });
+    }
+    else if (options.connector) {
+        options.baseUrl = options.connector.options.baseUrl;
+    }
+    options = deepmerge(OPTIONS, options);
+    if (!options.center && !options.bounds) {
+        options.bounds = [-179, -90, 180, 90];
+        // options.maxBounds = options.bounds;
+    }
+    if (options.connector) {
+        kits.push(new NgwKit({
+            connector: options.connector,
+            auth: options.auth,
+        }));
+    }
+    options = {
+        ...options,
+        starterKits: kits,
+        create: false,
+    };
+    return options;
 }
 
-var OPTIONS = {
-    target: 'map',
-    baseUrl: '',
-    whitlabel: false,
-    controls: getDefaultControls(),
-    controlsOptions: {
-        ZOOM: { position: 'top-left' },
-        ATTRIBUTION: {
-            position: 'bottom-right',
-            customAttribution: [
-                '<a href="https://nextgis.com" target="_blank">©NextGIS</a>',
-            ],
-        },
-    },
-    pixelRadius: 10,
-};
-function prepareWebMapOptions(options) {
-    var kits = [new QmsKit()];
-    if (options.starterKits) {
-        options.starterKits.forEach(function (x) {
-            kits.push(x);
-        });
-    }
-    if (!options.connector) {
-        options.connector = new NgwConnector({
-            baseUrl: options.baseUrl || '',
-            auth: options.auth,
-        });
-    }
-    else if (options.connector) {
-        options.baseUrl = options.connector.options.baseUrl;
-    }
-    options = deepmerge(OPTIONS, options);
-    if (!options.center && !options.bounds) {
-        options.bounds = [-179, -90, 180, 90];
-        // options.maxBounds = options.bounds;
-    }
-    if (options.connector) {
-        kits.push(new NgwKit({
-            connector: options.connector,
-            auth: options.auth,
-        }));
-    }
-    options = __assign(__assign({}, options), { starterKits: kits, create: false });
-    return options;
+/**
+ * Base class containing the logic of interaction WebMap with NextGIS services.
+ *
+ * @example
+ * ```javascript
+ * import { NgwMap } from '@nextgis/ngw-map';
+ * import MapAdapter from '@nextgis/leaflet-map-adapter';
+ * // styles are not included in the leaflet-map-adapter
+ * import 'leaflet/dist/leaflet.css';
+ *
+ * const ngwMap = new NgwMap({
+ *   mapAdapter: new MapAdapter(),
+ *   target: 'map',
+ *   qmsId: 448,
+ *   baseUrl: 'https://demo.nextgis.com',
+ *   webmapId: 3985
+ * });
+ * ```
+ */
+class NgwMap extends WebMap {
+    constructor(options) {
+        super(prepareWebMapOptions(options));
+        this.emitter = new EventEmitter();
+        this._ngwLayers = {};
+        this._promises = {
+            select: [],
+            identify: [],
+        };
+        if (options.connector) {
+            this.connector = options.connector;
+        }
+        this._createWebMap().then(() => {
+            const container = this.getContainer();
+            if (container) {
+                container.classList.add('ngw-map-container');
+            }
+            if (this.options.whitlabel) {
+                this._whiteLabel();
+            }
+        });
+    }
+    /**
+     * Organized addition to the map design and controls elements,
+     * calling `control.onAdd(this.webMap.mapAdapter)`
+     * @param control - object with onAdd and onRemove methods
+     *                or a string value indicating the name of the control installed in the map adapter
+     * @param position - position relative to the map angles
+     * @param options - initialization parameters if the control is set as a string value
+     *
+     * @example
+     * ```javascript
+     * ngwMap.addControl(new CustomControl(), 'bottom-left');
+     * ngwMap.addControl('ZOOM', 'top-right')
+     * ```
+     */
+    async addControl(controlDef, position, options) {
+        await this.onLoad('controls:create');
+        return super.addControl(controlDef, position, options);
+    }
+    /**
+     * Add any (style, vector, webmap) NGW layer by resource definition.
+     * @param options - set layer identification parameters and render method.
+     *
+     * @example
+     * ```javascript
+     * // Add raster layer resourceId is the style of 4004 layer
+     * ngwMap.addNgwLayer({ resource: 4005 });
+     * // Add vector data from layer GEOJSON source
+     * ngwMap.addNgwLayer({
+     *   resource: 4038,
+     *   adapter: 'GEOJSON',
+     *   adapterOptions: { paint: { color: 'red' } }
+     * });
+     * ```
+     */
+    async addNgwLayer(options) {
+        await this.onMapLoad();
+        // @ts-ignore for backward compatibility
+        const { keyname, resourceId } = options;
+        if (keyname || resourceId !== undefined) {
+            deprecatedWarn('set `resource` options instead of `keyname` or `resourceId`');
+        }
+        const resource = options.resource;
+        if (!keyname && !resourceId && !resource) {
+            throw new Error('resource, resourceId or keyname is required parameter to add NGW layer');
+        }
+        if (defined(this.options.baseUrl)) {
+            try {
+                if (defined(this.options.setViewDelay)) {
+                    options.adapterOptions = options.adapterOptions || {};
+                    if (!defined(options.adapterOptions.setViewDelay)) {
+                        options.adapterOptions.setViewDelay = this.options.setViewDelay;
+                    }
+                }
+                const adapter = createNgwLayerAdapter(options, this, this.connector);
+                const adapterOpts = {
+                    visibility: true,
+                    // TODO: do not merge options, use only `adapterOptions`
+                    ...options,
+                    ...options.adapterOptions,
+                };
+                const layer = (await this.addLayer(adapter, adapterOpts));
+                const id = layer && this.getLayerId(layer);
+                if (layer && id) {
+                    this._ngwLayers[id] = { layer, resourceId: layer.resourceId };
+                    layer.options.name =
+                        layer.options.name ||
+                            (layer.item && layer.item.resource.display_name);
+                    if (layer.options.baselayer) {
+                        const visibleLayerBaseLayer = this.getActiveBaseLayer();
+                        if (visibleLayerBaseLayer) {
+                            return layer;
+                        }
+                    }
+                }
+                return layer;
+            }
+            catch (er) {
+                const resId = isObject(resource) && 'id' in resource
+                    ? resource.id
+                    : keyname || resourceId || resource;
+                console.error(`Can't add NGW layer ${resId}.`, er);
+            }
+        }
+    }
+    /**
+     * Pans and zooms the map to the initial position specified in the options
+     */
+    fit() {
+        const { center, zoom, bounds } = this.options;
+        if (center) {
+            this.setCenter(center);
+            if (zoom) {
+                this.setZoom(zoom);
+            }
+        }
+        else if (bounds) {
+            this.fitBounds(bounds);
+        }
+    }
+    fetchNgwLayerItem(options) {
+        return fetchNgwLayerItem({
+            connector: this.connector,
+            ...options,
+        });
+    }
+    fetchNgwLayerItems(options) {
+        return fetchNgwLayerItems({
+            connector: this.connector,
+            ...options,
+        });
+    }
+    fetchNgwLayerFeature(options) {
+        return fetchNgwLayerFeature({
+            connector: this.connector,
+            ...options,
+        });
+    }
+    fetchNgwLayerFeatures(options) {
+        return fetchNgwLayerFeatureCollection({
+            connector: this.connector,
+            ...options,
+        });
+    }
+    fetchIdentifyItem(identify, requestOptions) {
+        const promise = fetchIdentifyItem({
+            identify,
+            connector: this.connector,
+            requestOptions,
+            // multiple,
+        });
+        this._addPromise('identify', promise);
+        return promise;
+    }
+    fetchIdentifyGeoJson(identify, multiple = false) {
+        const promise = fetchIdentifyGeoJson({
+            identify,
+            connector: this.connector,
+            multiple,
+        });
+        if (promise && 'then' in promise) {
+            this._addPromise('identify', promise);
+            return promise;
+        }
+        else {
+            return CancelablePromise.resolve(promise);
+        }
+    }
+    /**
+     * @deprecated use {@link fetchIdentifyGeoJson} instead
+     */
+    getIdentifyGeoJson(identify, multiple = false) {
+        return this.fetchIdentifyGeoJson(identify, multiple);
+    }
+    async getNgwLayers() {
+        await this.onLoad();
+        return this._ngwLayers;
+    }
+    async getNgwLayerByResourceId(id) {
+        for (const n in this._ngwLayers) {
+            const mem = this._ngwLayers[n];
+            if (mem.resourceId === id) {
+                return mem && mem.layer;
+            }
+            else if (mem.layer.getIdentificationIds) {
+                const ids = await mem.layer.getIdentificationIds();
+                if (ids && ids.some((x) => x === id)) {
+                    return mem.layer;
+                }
+            }
+            if (mem.layer.getDependLayers) {
+                const dependLayers = mem.layer.getDependLayers();
+                const dependFit = dependLayers.find((x) => {
+                    return x.item && x.item.parentId === id;
+                });
+                if (dependFit) {
+                    return dependFit.layer;
+                }
+            }
+        }
+    }
+    /**
+     * Move map to layer. If the layer is NGW resource, extent will be received from the server
+     *
+     * @example
+     * ```javascript
+     * const ngwLayer = ngwMap.addNgwLayer({ id: 'ngw_layer_name', resource: 4005 });
+     * ngwMap.fitLayer(ngwLayer);
+     * ngwMap.fitLayer('ngw_layer_name');
+     * ```
+     */
+    async fitLayer(layerDef, options) {
+        let id;
+        if (typeof layerDef === 'string' || typeof layerDef === 'number') {
+            id = String(id);
+        }
+        else {
+            id = layerDef.id;
+        }
+        const ngwLayer = id && this._ngwLayers[id];
+        if (ngwLayer) {
+            if (ngwLayer.layer.getBounds) {
+                const bounds = await ngwLayer.layer.getBounds();
+                if (bounds) {
+                    this.fitBounds(bounds, options);
+                }
+            }
+            else {
+                let item;
+                if (ngwLayer.layer.item) {
+                    item = ngwLayer.layer.item;
+                }
+                else {
+                    const resourceId = ngwLayer.resourceId;
+                    item = await this.connector.getResource(resourceId);
+                }
+                if (item) {
+                    fetchNgwExtent({
+                        resourceId: item.resource.id,
+                        connector: this.connector,
+                    }).then((extent) => {
+                        if (extent) {
+                            this.fitBounds(extent, options);
+                        }
+                    });
+                }
+            }
+        }
+        else {
+            super.fitLayer(typeof layerDef === 'number' ? String(layerDef) : layerDef, options);
+        }
+    }
+    /** @deprecated use {@link fitLayer} instead */
+    async zoomToLayer(layerDef) {
+        return this.fitLayer(layerDef);
+    }
+    onLoad(event = 'ngw-map:create') {
+        return super.onLoad(event);
+    }
+    removeLayer(layerDef) {
+        const layer = this.getLayer(layerDef);
+        if (layer) {
+            const layerId = this.getLayerId(layer);
+            if (layerId) {
+                delete this._ngwLayers[layerId];
+            }
+            super.removeLayer(layer);
+        }
+    }
+    enableSelection() {
+        if (!this.$$selectFromNgwRaster) {
+            this.$$selectFromNgwRaster = (ev) => {
+                const count = this._getSelectListenersCount();
+                if (count) {
+                    this.selectFromNgwRaster(ev);
+                }
+            };
+            this.$$selectFromNgwVector = (ev) => {
+                const count = this._getSelectListenersCount();
+                if (count) {
+                    this._selectFromNgwVector(ev);
+                }
+            };
+            this.emitter.on('click', this.$$selectFromNgwRaster);
+            this.emitter.on('layer:click', this.$$selectFromNgwVector);
+        }
+    }
+    disableSelection() {
+        if (this.$$selectFromNgwRaster) {
+            this.emitter.removeListener('click', this.$$selectFromNgwRaster);
+            this.$$selectFromNgwRaster = undefined;
+        }
+        if (this.$$selectFromNgwVector) {
+            this.emitter.removeListener('layer:click', this.$$selectFromNgwVector);
+            this.$$selectFromNgwVector = undefined;
+        }
+    }
+    /**
+     * @deprecated use {@link fetchNgwLayerItem} instead
+     */
+    getNgwLayerItem(options) {
+        return this.fetchNgwLayerItem(options);
+    }
+    /**
+     * @deprecated use {@link fetchNgwLayerItems} instead
+     */
+    getNgwLayerItems(options) {
+        return this.fetchNgwLayerItems(options);
+    }
+    /**
+     * @deprecated use {@link fetchNgwLayerFeature} instead
+     */
+    getNgwLayerFeature(options) {
+        return this.fetchNgwLayerFeature(options);
+    }
+    /**
+     * @deprecated use {@link fetchNgwLayerFeatures} instead
+     */
+    getNgwLayerFeatures(options) {
+        return this.fetchNgwLayerFeatures(options);
+    }
+    /** @deprecated use {@link cancelPromises} instead */
+    cancelPromise(...args) {
+        this.cancelPromises(...args);
+    }
+    cancelPromises(...args) {
+        if (!args.length) {
+            args = Object.keys(this._promises);
+        }
+        args.forEach((name) => {
+            const group = this._promises[name];
+            if (group) {
+                group.forEach((x) => x.cancel());
+                this._promises[name] = [];
+            }
+        });
+    }
+    async selectFromNgwRaster(ev) {
+        this._emitStatusEvent('ngw:preselect');
+        const promises = [];
+        const layers = Object.values(this._ngwLayers);
+        layers.sort((a, b) => {
+            if (a.layer.order && b.layer.order) {
+                return b.layer.order - a.layer.order;
+            }
+            return 1;
+        });
+        for (const l of layers) {
+            const layer = l.layer;
+            const identFunc = typeof layer.getIdentificationIds === 'function'
+                ? layer.getIdentificationIds
+                : false;
+            if (identFunc && layer.options.selectable && this.isLayerVisible(layer)) {
+                promises.push(identFunc.call(layer));
+            }
+        }
+        const getIdsPromise = Promise.all(promises);
+        const getIds = await getIdsPromise;
+        const ids = [];
+        for (const x of getIds) {
+            if (x) {
+                ids.push(...x);
+            }
+        }
+        if (!ids.length) {
+            this._emitStatusEvent('ngw:select', null);
+            return;
+        }
+        const pixelRadius = this.options.pixelRadius || 10;
+        const center = this.getCenter();
+        let zoom = this.getZoom();
+        zoom = zoom !== undefined ? zoom : 20;
+        if (!center || !zoom) {
+            this._emitStatusEvent('ngw:select', null);
+            return;
+        }
+        const radius = getIdentifyRadius(center, zoom, pixelRadius);
+        const selectPromise = sendIdentifyRequest(ev, {
+            layers: ids,
+            connector: this.connector,
+            radius,
+        }).then((resp) => {
+            const identify = {
+                ...resp,
+                resources: ids,
+                sourceType: 'raster',
+                event: ev,
+            };
+            const identifyEvent = this._prepareToIdentify(identify);
+            this._emitStatusEvent('ngw:select', identifyEvent);
+            return identifyEvent;
+        });
+        this._addPromise('select', selectPromise);
+        return selectPromise;
+    }
+    _addPromise(groupName, promise) {
+        const group = this._promises[groupName];
+        if (group && group.indexOf(promise) === -1) {
+            const removeFromGroup = () => {
+                const index = group.indexOf(promise);
+                if (index !== -1) {
+                    group.splice(index, 1);
+                }
+            };
+            promise.then(removeFromGroup);
+            promise.catch(removeFromGroup);
+            group.push(promise);
+        }
+    }
+    _isFitFromResource() {
+        const params = this._initMapState;
+        if (params.zoom && params.center) {
+            return false;
+        }
+        return true;
+    }
+    async _createWebMap() {
+        await this.create();
+        if (this.options.qmsId) {
+            this._addQmsBaseLayer();
+        }
+        if (this.options.osm) {
+            this._addOsmBaseLayer();
+        }
+        const resources = [];
+        const layerFitAllowed = this._isFitFromResource();
+        if (this.options.webmapId) {
+            appendNgwResources(resources, this.options.webmapId, {
+                fit: layerFitAllowed,
+            });
+        }
+        if (this.options.resources && Array.isArray(this.options.resources)) {
+            for (const x of this.options.resources) {
+                const overwriteOptions = {};
+                if (!layerFitAllowed) {
+                    overwriteOptions.fit = false;
+                }
+                appendNgwResources(resources, x, {}, overwriteOptions);
+            }
+        }
+        for (const r of resources) {
+            try {
+                await this.addNgwLayer(r);
+            }
+            catch (er) {
+                console.warn(er);
+            }
+        }
+        this._emitStatusEvent('ngw-map:create', this);
+        this.enableSelection();
+    }
+    _addOsmBaseLayer() {
+        this.addBaseLayer('OSM');
+    }
+    _addQmsBaseLayer() {
+        let qmsId;
+        let qmsLayerName;
+        if (Array.isArray(this.options.qmsId)) {
+            qmsId = this.options.qmsId[0];
+            qmsLayerName = this.options.qmsId[1];
+        }
+        else {
+            qmsId = Number(this.options.qmsId);
+        }
+        const qmsLayerOptions = {
+            qmsId,
+        };
+        if (qmsLayerName) {
+            qmsLayerOptions.id = qmsLayerName;
+        }
+        this.addBaseLayer('QMS', qmsLayerOptions);
+    }
+    _selectFromNgwVector(ev) {
+        const layer = ev.layer;
+        const selectable = layer.options.selectable && this.isLayerVisible(layer);
+        if (!selectable) {
+            return undefined;
+        }
+        // Item property means layer is NgwResource
+        const id = layer.item && layer.item.resource.id;
+        const feature = ev.feature;
+        if (id !== undefined && feature) {
+            const featureId = feature.id;
+            if (featureId) {
+                const identifyFeature = {
+                    id: Number(featureId),
+                    fields: feature.properties || {},
+                    label: `#${id}`,
+                    layerId: Number(id),
+                    parent: '',
+                    geom: feature.geometry,
+                };
+                const items = {
+                    featureCount: 1,
+                    features: [identifyFeature],
+                };
+                const identify = {
+                    featureCount: 1,
+                    [id]: items,
+                };
+                this._emitStatusEvent('ngw:select', this._prepareToIdentify({
+                    ...identify,
+                    resources: [id],
+                    sourceType: 'vector',
+                }));
+                return identify;
+            }
+        }
+    }
+    _prepareToIdentify(identify) {
+        const getIdentifyItems_ = () => {
+            return getIdentifyItems(identify, true).map((x) => {
+                return createIdentifyItem({
+                    feature: x.feature,
+                    connector: this.connector,
+                });
+            });
+        };
+        return {
+            ...identify,
+            getIdentifyItems: getIdentifyItems_,
+        };
+    }
+    _getSelectListenersCount() {
+        return this.emitter.listenerCount('ngw:select');
+    }
+    async _whiteLabel() {
+        const container = this.getContainer();
+        if (container) {
+            const logo = await getCompanyLogo(this.connector, this.options.companyLogoOptions);
+            if (logo) {
+                container.appendChild(logo);
+            }
+        }
+    }
 }
+NgwMap.getIcon = getIcon;
 
-/**
- * Base class containing the logic of interaction WebMap with NextGIS services.
- *
- * @example
- * ```javascript
- * import { NgwMap } from '@nextgis/ngw-map';
- * import MapAdapter from '@nextgis/leaflet-map-adapter';
- * // styles are not included in the leaflet-map-adapter
- * import 'leaflet/dist/leaflet.css';
- *
- * const ngwMap = new NgwMap({
- *   mapAdapter: new MapAdapter(),
- *   target: 'map',
- *   qmsId: 448,
- *   baseUrl: 'https://demo.nextgis.com',
- *   webmapId: 3985
- * });
- * ```
- */
-var NgwMap = /** @class */ (function (_super) {
-    __extends(NgwMap, _super);
-    function NgwMap(options) {
-        var _this = _super.call(this, prepareWebMapOptions(options)) || this;
-        _this.emitter = new EventEmitter();
-        _this._ngwLayers = {};
-        _this._promises = {
-            select: [],
-            identify: [],
-        };
-        if (options.connector) {
-            _this.connector = options.connector;
-        }
-        _this._createWebMap().then(function () {
-            var container = _this.getContainer();
-            if (container) {
-                container.classList.add('ngw-map-container');
-            }
-            if (_this.options.whitlabel) {
-                _this._whiteLabel();
-            }
-        });
-        return _this;
-    }
-    /**
-     * Organized addition to the map design and controls elements,
-     * calling `control.onAdd(this.webMap.mapAdapter)`
-     * @param control - object with onAdd and onRemove methods
-     *                or a string value indicating the name of the control installed in the map adapter
-     * @param position - position relative to the map angles
-     * @param options - initialization parameters if the control is set as a string value
-     *
-     * @example
-     * ```javascript
-     * ngwMap.addControl(new CustomControl(), 'bottom-left');
-     * ngwMap.addControl('ZOOM', 'top-right')
-     * ```
-     */
-    NgwMap.prototype.addControl = function (controlDef, position, options) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.onLoad('controls:create')];
-                    case 1:
-                        _a.sent();
-                        return [2 /*return*/, _super.prototype.addControl.call(this, controlDef, position, options)];
-                }
-            });
-        });
-    };
-    /**
-     * Add any (style, vector, webmap) NGW layer by resource definition.
-     * @param options - set layer identification parameters and render method.
-     *
-     * @example
-     * ```javascript
-     * // Add raster layer resourceId is the style of 4004 layer
-     * ngwMap.addNgwLayer({ resource: 4005 });
-     * // Add vector data from layer GEOJSON source
-     * ngwMap.addNgwLayer({
-     *   resource: 4038,
-     *   adapter: 'GEOJSON',
-     *   adapterOptions: { paint: { color: 'red' } }
-     * });
-     * ```
-     */
-    NgwMap.prototype.addNgwLayer = function (options) {
-        return __awaiter(this, void 0, void 0, function () {
-            var keyname, resourceId, resource, adapter, adapterOpts, layer, id, visibleLayerBaseLayer, er_1, resId;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.onMapLoad()];
-                    case 1:
-                        _a.sent();
-                        keyname = options.keyname, resourceId = options.resourceId;
-                        if (keyname || resourceId !== undefined) {
-                            deprecatedWarn('set `resource` options instead of `keyname` or `resourceId`');
-                        }
-                        resource = options.resource;
-                        if (!keyname && !resourceId && !resource) {
-                            throw new Error('resource, resourceId or keyname is required parameter to add NGW layer');
-                        }
-                        if (!defined(this.options.baseUrl)) return [3 /*break*/, 5];
-                        _a.label = 2;
-                    case 2:
-                        _a.trys.push([2, 4, , 5]);
-                        if (defined(this.options.setViewDelay)) {
-                            options.adapterOptions = options.adapterOptions || {};
-                            if (!defined(options.adapterOptions.setViewDelay)) {
-                                options.adapterOptions.setViewDelay = this.options.setViewDelay;
-                            }
-                        }
-                        adapter = createNgwLayerAdapter(options, this, this.connector);
-                        adapterOpts = __assign(__assign({ visibility: true }, options), options.adapterOptions);
-                        return [4 /*yield*/, this.addLayer(adapter, adapterOpts)];
-                    case 3:
-                        layer = (_a.sent());
-                        id = layer && this.getLayerId(layer);
-                        if (layer && id) {
-                            this._ngwLayers[id] = { layer: layer, resourceId: layer.resourceId };
-                            layer.options.name =
-                                layer.options.name ||
-                                    (layer.item && layer.item.resource.display_name);
-                            if (layer.options.baselayer) {
-                                visibleLayerBaseLayer = this.getActiveBaseLayer();
-                                if (visibleLayerBaseLayer) {
-                                    return [2 /*return*/, layer];
-                                }
-                            }
-                        }
-                        return [2 /*return*/, layer];
-                    case 4:
-                        er_1 = _a.sent();
-                        resId = isObject(resource) && 'id' in resource
-                            ? resource.id
-                            : keyname || resourceId || resource;
-                        console.error("Can't add NGW layer ".concat(resId, "."), er_1);
-                        return [3 /*break*/, 5];
-                    case 5: return [2 /*return*/];
-                }
-            });
-        });
-    };
-    /**
-     * Pans and zooms the map to the initial position specified in the options
-     */
-    NgwMap.prototype.fit = function () {
-        var _a = this.options, center = _a.center, zoom = _a.zoom, bounds = _a.bounds;
-        if (center) {
-            this.setCenter(center);
-            if (zoom) {
-                this.setZoom(zoom);
-            }
-        }
-        else if (bounds) {
-            this.fitBounds(bounds);
-        }
-    };
-    NgwMap.prototype.fetchNgwLayerItem = function (options) {
-        return fetchNgwLayerItem(__assign({ connector: this.connector }, options));
-    };
-    NgwMap.prototype.fetchNgwLayerItems = function (options) {
-        return fetchNgwLayerItems(__assign({ connector: this.connector }, options));
-    };
-    NgwMap.prototype.fetchNgwLayerFeature = function (options) {
-        return fetchNgwLayerFeature(__assign({ connector: this.connector }, options));
-    };
-    NgwMap.prototype.fetchNgwLayerFeatures = function (options) {
-        return fetchNgwLayerFeatureCollection(__assign({ connector: this.connector }, options));
-    };
-    NgwMap.prototype.fetchIdentifyItem = function (identify, requestOptions) {
-        var promise = fetchIdentifyItem({
-            identify: identify,
-            connector: this.connector,
-            requestOptions: requestOptions,
-            // multiple,
-        });
-        this._addPromise('identify', promise);
-        return promise;
-    };
-    NgwMap.prototype.fetchIdentifyGeoJson = function (identify, multiple) {
-        if (multiple === void 0) { multiple = false; }
-        var promise = fetchIdentifyGeoJson({
-            identify: identify,
-            connector: this.connector,
-            multiple: multiple,
-        });
-        if (promise && 'then' in promise) {
-            this._addPromise('identify', promise);
-            return promise;
-        }
-        else {
-            return CancelablePromise.resolve(promise);
-        }
-    };
-    /**
-     * @deprecated use {@link fetchIdentifyGeoJson} instead
-     */
-    NgwMap.prototype.getIdentifyGeoJson = function (identify, multiple) {
-        if (multiple === void 0) { multiple = false; }
-        return this.fetchIdentifyGeoJson(identify, multiple);
-    };
-    NgwMap.prototype.getNgwLayers = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.onLoad()];
-                    case 1:
-                        _a.sent();
-                        return [2 /*return*/, this._ngwLayers];
-                }
-            });
-        });
-    };
-    NgwMap.prototype.getNgwLayerByResourceId = function (id) {
-        return __awaiter(this, void 0, void 0, function () {
-            var _a, _b, _i, n, mem, ids, dependLayers, dependFit;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        _a = [];
-                        for (_b in this._ngwLayers)
-                            _a.push(_b);
-                        _i = 0;
-                        _c.label = 1;
-                    case 1:
-                        if (!(_i < _a.length)) return [3 /*break*/, 6];
-                        n = _a[_i];
-                        mem = this._ngwLayers[n];
-                        if (!(mem.resourceId === id)) return [3 /*break*/, 2];
-                        return [2 /*return*/, mem && mem.layer];
-                    case 2:
-                        if (!mem.layer.getIdentificationIds) return [3 /*break*/, 4];
-                        return [4 /*yield*/, mem.layer.getIdentificationIds()];
-                    case 3:
-                        ids = _c.sent();
-                        if (ids && ids.some(function (x) { return x === id; })) {
-                            return [2 /*return*/, mem.layer];
-                        }
-                        _c.label = 4;
-                    case 4:
-                        if (mem.layer.getDependLayers) {
-                            dependLayers = mem.layer.getDependLayers();
-                            dependFit = dependLayers.find(function (x) {
-                                return x.item && x.item.parentId === id;
-                            });
-                            if (dependFit) {
-                                return [2 /*return*/, dependFit.layer];
-                            }
-                        }
-                        _c.label = 5;
-                    case 5:
-                        _i++;
-                        return [3 /*break*/, 1];
-                    case 6: return [2 /*return*/];
-                }
-            });
-        });
-    };
-    /**
-     * Move map to layer. If the layer is NGW resource, extent will be received from the server
-     *
-     * @example
-     * ```javascript
-     * const ngwLayer = ngwMap.addNgwLayer({ id: 'ngw_layer_name', resource: 4005 });
-     * ngwMap.fitLayer(ngwLayer);
-     * ngwMap.fitLayer('ngw_layer_name');
-     * ```
-     */
-    NgwMap.prototype.fitLayer = function (layerDef, options) {
-        return __awaiter(this, void 0, void 0, function () {
-            var id, ngwLayer, bounds, item, resourceId;
-            var _this = this;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (typeof layerDef === 'string' || typeof layerDef === 'number') {
-                            id = String(id);
-                        }
-                        else {
-                            id = layerDef.id;
-                        }
-                        ngwLayer = id && this._ngwLayers[id];
-                        if (!ngwLayer) return [3 /*break*/, 7];
-                        if (!ngwLayer.layer.getBounds) return [3 /*break*/, 2];
-                        return [4 /*yield*/, ngwLayer.layer.getBounds()];
-                    case 1:
-                        bounds = _a.sent();
-                        if (bounds) {
-                            this.fitBounds(bounds, options);
-                        }
-                        return [3 /*break*/, 6];
-                    case 2:
-                        item = void 0;
-                        if (!ngwLayer.layer.item) return [3 /*break*/, 3];
-                        item = ngwLayer.layer.item;
-                        return [3 /*break*/, 5];
-                    case 3:
-                        resourceId = ngwLayer.resourceId;
-                        return [4 /*yield*/, this.connector.getResource(resourceId)];
-                    case 4:
-                        item = _a.sent();
-                        _a.label = 5;
-                    case 5:
-                        if (item) {
-                            fetchNgwExtent({
-                                resourceId: item.resource.id,
-                                connector: this.connector,
-                            }).then(function (extent) {
-                                if (extent) {
-                                    _this.fitBounds(extent, options);
-                                }
-                            });
-                        }
-                        _a.label = 6;
-                    case 6: return [3 /*break*/, 8];
-                    case 7:
-                        _super.prototype.fitLayer.call(this, typeof layerDef === 'number' ? String(layerDef) : layerDef, options);
-                        _a.label = 8;
-                    case 8: return [2 /*return*/];
-                }
-            });
-        });
-    };
-    /** @deprecated use {@link fitLayer} instead */
-    NgwMap.prototype.zoomToLayer = function (layerDef) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.fitLayer(layerDef)];
-            });
-        });
-    };
-    NgwMap.prototype.onLoad = function (event) {
-        if (event === void 0) { event = 'ngw-map:create'; }
-        return _super.prototype.onLoad.call(this, event);
-    };
-    NgwMap.prototype.removeLayer = function (layerDef) {
-        var layer = this.getLayer(layerDef);
-        if (layer) {
-            var layerId = this.getLayerId(layer);
-            if (layerId) {
-                delete this._ngwLayers[layerId];
-            }
-            _super.prototype.removeLayer.call(this, layer);
-        }
-    };
-    NgwMap.prototype.enableSelection = function () {
-        var _this = this;
-        if (!this.$$selectFromNgwRaster) {
-            this.$$selectFromNgwRaster = function (ev) {
-                var count = _this._getSelectListenersCount();
-                if (count) {
-                    _this.selectFromNgwRaster(ev);
-                }
-            };
-            this.$$selectFromNgwVector = function (ev) {
-                var count = _this._getSelectListenersCount();
-                if (count) {
-                    _this._selectFromNgwVector(ev);
-                }
-            };
-            this.emitter.on('click', this.$$selectFromNgwRaster);
-            this.emitter.on('layer:click', this.$$selectFromNgwVector);
-        }
-    };
-    NgwMap.prototype.disableSelection = function () {
-        if (this.$$selectFromNgwRaster) {
-            this.emitter.removeListener('click', this.$$selectFromNgwRaster);
-            this.$$selectFromNgwRaster = undefined;
-        }
-        if (this.$$selectFromNgwVector) {
-            this.emitter.removeListener('layer:click', this.$$selectFromNgwVector);
-            this.$$selectFromNgwVector = undefined;
-        }
-    };
-    /**
-     * @deprecated use {@link fetchNgwLayerItem} instead
-     */
-    NgwMap.prototype.getNgwLayerItem = function (options) {
-        return this.fetchNgwLayerItem(options);
-    };
-    /**
-     * @deprecated use {@link fetchNgwLayerItems} instead
-     */
-    NgwMap.prototype.getNgwLayerItems = function (options) {
-        return this.fetchNgwLayerItems(options);
-    };
-    /**
-     * @deprecated use {@link fetchNgwLayerFeature} instead
-     */
-    NgwMap.prototype.getNgwLayerFeature = function (options) {
-        return this.fetchNgwLayerFeature(options);
-    };
-    /**
-     * @deprecated use {@link fetchNgwLayerFeatures} instead
-     */
-    NgwMap.prototype.getNgwLayerFeatures = function (options) {
-        return this.fetchNgwLayerFeatures(options);
-    };
-    /** @deprecated use {@link cancelPromises} instead */
-    NgwMap.prototype.cancelPromise = function () {
-        var args = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            args[_i] = arguments[_i];
-        }
-        this.cancelPromises.apply(this, args);
-    };
-    NgwMap.prototype.cancelPromises = function () {
-        var _this = this;
-        var args = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            args[_i] = arguments[_i];
-        }
-        if (!args.length) {
-            args = Object.keys(this._promises);
-        }
-        args.forEach(function (name) {
-            var group = _this._promises[name];
-            if (group) {
-                group.forEach(function (x) { return x.cancel(); });
-                _this._promises[name] = [];
-            }
-        });
-    };
-    NgwMap.prototype.selectFromNgwRaster = function (ev) {
-        return __awaiter(this, void 0, void 0, function () {
-            var promises, layers, _i, layers_1, l, layer, identFunc, getIdsPromise, getIds, ids, _a, getIds_1, x, pixelRadius, center, zoom, radius, selectPromise;
-            var _this = this;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        this._emitStatusEvent('ngw:preselect');
-                        promises = [];
-                        layers = Object.values(this._ngwLayers);
-                        layers.sort(function (a, b) {
-                            if (a.layer.order && b.layer.order) {
-                                return b.layer.order - a.layer.order;
-                            }
-                            return 1;
-                        });
-                        for (_i = 0, layers_1 = layers; _i < layers_1.length; _i++) {
-                            l = layers_1[_i];
-                            layer = l.layer;
-                            identFunc = typeof layer.getIdentificationIds === 'function'
-                                ? layer.getIdentificationIds
-                                : false;
-                            if (identFunc && layer.options.selectable && this.isLayerVisible(layer)) {
-                                promises.push(identFunc.call(layer));
-                            }
-                        }
-                        getIdsPromise = Promise.all(promises);
-                        return [4 /*yield*/, getIdsPromise];
-                    case 1:
-                        getIds = _b.sent();
-                        ids = [];
-                        for (_a = 0, getIds_1 = getIds; _a < getIds_1.length; _a++) {
-                            x = getIds_1[_a];
-                            if (x) {
-                                ids.push.apply(ids, x);
-                            }
-                        }
-                        if (!ids.length) {
-                            this._emitStatusEvent('ngw:select', null);
-                            return [2 /*return*/];
-                        }
-                        pixelRadius = this.options.pixelRadius || 10;
-                        center = this.getCenter();
-                        zoom = this.getZoom();
-                        zoom = zoom !== undefined ? zoom : 20;
-                        if (!center || !zoom) {
-                            this._emitStatusEvent('ngw:select', null);
-                            return [2 /*return*/];
-                        }
-                        radius = getIdentifyRadius(center, zoom, pixelRadius);
-                        selectPromise = sendIdentifyRequest(ev, {
-                            layers: ids,
-                            connector: this.connector,
-                            radius: radius,
-                        }).then(function (resp) {
-                            var identify = __assign(__assign({}, resp), { resources: ids, sourceType: 'raster', event: ev });
-                            var identifyEvent = _this._prepareToIdentify(identify);
-                            _this._emitStatusEvent('ngw:select', identifyEvent);
-                            return identifyEvent;
-                        });
-                        this._addPromise('select', selectPromise);
-                        return [2 /*return*/, selectPromise];
-                }
-            });
-        });
-    };
-    NgwMap.prototype._addPromise = function (groupName, promise) {
-        var group = this._promises[groupName];
-        if (group && group.indexOf(promise) === -1) {
-            var removeFromGroup = function () {
-                var index = group.indexOf(promise);
-                if (index !== -1) {
-                    group.splice(index, 1);
-                }
-            };
-            promise.then(removeFromGroup);
-            promise.catch(removeFromGroup);
-            group.push(promise);
-        }
-    };
-    NgwMap.prototype._isFitFromResource = function () {
-        var params = this._initMapState;
-        if (params.zoom && params.center) {
-            return false;
-        }
-        return true;
-    };
-    NgwMap.prototype._createWebMap = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var resources, layerFitAllowed, _i, _a, x, overwriteOptions, _b, resources_1, r, er_2;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0: return [4 /*yield*/, this.create()];
-                    case 1:
-                        _c.sent();
-                        if (this.options.qmsId) {
-                            this._addQmsBaseLayer();
-                        }
-                        if (this.options.osm) {
-                            this._addOsmBaseLayer();
-                        }
-                        resources = [];
-                        layerFitAllowed = this._isFitFromResource();
-                        if (this.options.webmapId) {
-                            appendNgwResources(resources, this.options.webmapId, {
-                                fit: layerFitAllowed,
-                            });
-                        }
-                        if (this.options.resources && Array.isArray(this.options.resources)) {
-                            for (_i = 0, _a = this.options.resources; _i < _a.length; _i++) {
-                                x = _a[_i];
-                                overwriteOptions = {};
-                                if (!layerFitAllowed) {
-                                    overwriteOptions.fit = false;
-                                }
-                                appendNgwResources(resources, x, {}, overwriteOptions);
-                            }
-                        }
-                        _b = 0, resources_1 = resources;
-                        _c.label = 2;
-                    case 2:
-                        if (!(_b < resources_1.length)) return [3 /*break*/, 7];
-                        r = resources_1[_b];
-                        _c.label = 3;
-                    case 3:
-                        _c.trys.push([3, 5, , 6]);
-                        return [4 /*yield*/, this.addNgwLayer(r)];
-                    case 4:
-                        _c.sent();
-                        return [3 /*break*/, 6];
-                    case 5:
-                        er_2 = _c.sent();
-                        console.warn(er_2);
-                        return [3 /*break*/, 6];
-                    case 6:
-                        _b++;
-                        return [3 /*break*/, 2];
-                    case 7:
-                        this._emitStatusEvent('ngw-map:create', this);
-                        this.enableSelection();
-                        return [2 /*return*/];
-                }
-            });
-        });
-    };
-    NgwMap.prototype._addOsmBaseLayer = function () {
-        this.addBaseLayer('OSM');
-    };
-    NgwMap.prototype._addQmsBaseLayer = function () {
-        var qmsId;
-        var qmsLayerName;
-        if (Array.isArray(this.options.qmsId)) {
-            qmsId = this.options.qmsId[0];
-            qmsLayerName = this.options.qmsId[1];
-        }
-        else {
-            qmsId = Number(this.options.qmsId);
-        }
-        var qmsLayerOptions = {
-            qmsId: qmsId,
-        };
-        if (qmsLayerName) {
-            qmsLayerOptions.id = qmsLayerName;
-        }
-        this.addBaseLayer('QMS', qmsLayerOptions);
-    };
-    NgwMap.prototype._selectFromNgwVector = function (ev) {
-        var _a;
-        var layer = ev.layer;
-        var selectable = layer.options.selectable && this.isLayerVisible(layer);
-        if (!selectable) {
-            return undefined;
-        }
-        // Item property means layer is NgwResource
-        var id = layer.item && layer.item.resource.id;
-        var feature = ev.feature;
-        if (id !== undefined && feature) {
-            var featureId = feature.id;
-            if (featureId) {
-                var identifyFeature = {
-                    id: Number(featureId),
-                    fields: feature.properties || {},
-                    label: "#".concat(id),
-                    layerId: Number(id),
-                    parent: '',
-                    geom: feature.geometry,
-                };
-                var items = {
-                    featureCount: 1,
-                    features: [identifyFeature],
-                };
-                var identify = (_a = {
-                        featureCount: 1
-                    },
-                    _a[id] = items,
-                    _a);
-                this._emitStatusEvent('ngw:select', this._prepareToIdentify(__assign(__assign({}, identify), { resources: [id], sourceType: 'vector' })));
-                return identify;
-            }
-        }
-    };
-    NgwMap.prototype._prepareToIdentify = function (identify) {
-        var _this = this;
-        var getIdentifyItems_ = function () {
-            return getIdentifyItems(identify, true).map(function (x) {
-                return createIdentifyItem({
-                    feature: x.feature,
-                    connector: _this.connector,
-                });
-            });
-        };
-        return __assign(__assign({}, identify), { getIdentifyItems: getIdentifyItems_ });
-    };
-    NgwMap.prototype._getSelectListenersCount = function () {
-        return this.emitter.listenerCount('ngw:select');
-    };
-    NgwMap.prototype._whiteLabel = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var container, logo;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        container = this.getContainer();
-                        if (!container) return [3 /*break*/, 2];
-                        return [4 /*yield*/, getCompanyLogo(this.connector, this.options.companyLogoOptions)];
-                    case 1:
-                        logo = _a.sent();
-                        if (logo) {
-                            container.appendChild(logo);
-                        }
-                        _a.label = 2;
-                    case 2: return [2 /*return*/];
-                }
-            });
-        });
-    };
-    NgwMap.getIcon = getIcon;
-    return NgwMap;
-}(WebMap));
-
-/**
- * @module ngw-map
- */
-function createNgwMap(options) {
-    return __awaiter(this, void 0, void 0, function () {
-        var ngwMap;
-        return __generator(this, function (_a) {
-            ngwMap = new NgwMap(options);
-            return [2 /*return*/, ngwMap.onLoad()];
-        });
-    });
+/**
+ * @module ngw-map
+ */
+async function createNgwMap(options) {
+    const ngwMap = new NgwMap(options);
+    return ngwMap.onLoad();
 }
 
 export { NgwMap, createNgwMap };