@nextgis/ngw-map 1.11.10 → 1.13.0

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

@@ -1,37 +1,109 @@
-/** Bundle of @nextgis/ngw-map; version: 1.11.10; author: NextGIS */
+/** Bundle of @nextgis/ngw-map; version: 1.13.0; author: NextGIS */
 import { EventEmitter } from 'events';
 import CancelablePromise from '@nextgis/cancelable-promise';
-import { deepmerge, deprecatedWarn, defined, isObject } from '@nextgis/utils';
+import { deepmerge, isObject, defined, deprecatedWarn } from '@nextgis/utils';
 import { WebMap } from '@nextgis/webmap';
 export * from '@nextgis/webmap';
-import { NgwKit, createNgwLayerAdapter, fetchNgwLayerItem, fetchNgwLayerItems, fetchNgwLayerFeature, fetchNgwLayerFeatureCollection, fetchIdentifyItem, fetchIdentifyGeoJson, fetchNgwResourceExtent, sendIdentifyRequest, getCompanyLogo, getIdentifyItems, createIdentifyItem } from '@nextgis/ngw-kit';
+import { NgwKit, fetchNgwLayerItem, fetchNgwLayerItems, fetchNgwLayerFeature, fetchNgwLayerFeatureCollection, fetchIdentifyItem, fetchIdentifyGeoJson, getIdentifyItems, createIdentifyItem, createNgwLayerAdapter, sendIdentifyRequest, getCompanyLogo, fetchNgwResourceExtent } 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,
-        });
+        options.push(__assign(__assign({}, defOptions), { resource: resource }));
     }
     else if (Array.isArray(resource)) {
-        const [resourceId, id] = resource;
-        options.push({
-            ...defOptions,
-            resource: resourceId,
-            id,
-            ...overwriteOptions,
-        });
+        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({ ...defOptions, ...resource, ...overwriteOptions });
+        options.push(__assign(__assign(__assign({}, defOptions), resource), overwriteOptions));
     }
 }
 
-const OPTIONS = {
+var OPTIONS = {
     target: 'map',
     baseUrl: '',
     whitlabel: false,
@@ -48,9 +120,9 @@ const OPTIONS = {
     pixelRadius: 10,
 };
 function prepareWebMapOptions(options) {
-    const kits = [new QmsKit()];
+    var kits = [new QmsKit()];
     if (options.starterKits) {
-        options.starterKits.forEach((x) => {
+        options.starterKits.forEach(function (x) {
             kits.push(x);
         });
     }
@@ -74,19 +146,15 @@ function prepareWebMapOptions(options) {
             auth: options.auth,
         }));
     }
-    options = {
-        ...options,
-        starterKits: kits,
-        create: false,
-    };
+    options = __assign(__assign({}, options), { starterKits: kits, create: false });
     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))) /
+    var metresPerPixel = (40075016.686 * Math.abs(Math.cos((center[1] * 180) / Math.PI))) /
         Math.pow(2, zoom + 8);
-    const radius = pixelRadius * metresPerPixel * 0.0005;
+    var radius = pixelRadius * metresPerPixel * 0.0005;
     return radius;
 }
 
@@ -109,27 +177,29 @@ function getIdentifyRadius(center, zoom, pixelRadius) {
  * });
  * ```
  */
-class NgwMap extends WebMap {
-    constructor(options) {
-        super(prepareWebMapOptions(options));
-        this.emitter = new EventEmitter();
-        this._ngwLayers = {};
-        this._promises = {
+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.connector = options.connector;
         }
-        this._createWebMap().then(() => {
-            const container = this.getContainer();
+        _this._createWebMap().then(function () {
+            var container = _this.getContainer();
             if (container) {
                 container.classList.add('ngw-map-container');
             }
-            if (this.options.whitlabel) {
-                this._whiteLabel();
+            if (_this.options.whitlabel) {
+                _this._whiteLabel();
             }
         });
+        return _this;
     }
     /**
      * Organized addition to the map design and controls elements,
@@ -145,10 +215,18 @@ class NgwMap extends WebMap {
      * ngwMap.addControl('ZOOM', 'top-right')
      * ```
      */
-    async addControl(controlDef, position, options) {
-        await this.onLoad('controls:create');
-        return super.addControl(controlDef, position, options);
-    }
+    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.
@@ -165,61 +243,68 @@ class NgwMap extends WebMap {
      * });
      * ```
      */
-    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;
+    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*/];
                 }
-                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;
+    NgwMap.prototype.fit = function () {
+        var _a = this.options, center = _a.center, zoom = _a.zoom, bounds = _a.bounds;
         if (center) {
             this.setCenter(center);
             if (zoom) {
@@ -229,46 +314,35 @@ class NgwMap extends WebMap {
         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,
+    };
+    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: requestOptions,
             // multiple,
         });
         this._addPromise('identify', promise);
         return promise;
-    }
-    fetchIdentifyGeoJson(identify, multiple = false) {
-        const promise = fetchIdentifyGeoJson({
-            identify,
+    };
+    NgwMap.prototype.fetchIdentifyGeoJson = function (identify, multiple) {
+        if (multiple === void 0) { multiple = false; }
+        var promise = fetchIdentifyGeoJson({
+            identify: identify,
             connector: this.connector,
-            multiple,
+            multiple: multiple,
         });
         if (promise && 'then' in promise) {
             this._addPromise('identify', promise);
@@ -277,40 +351,71 @@ class NgwMap extends WebMap {
         else {
             return CancelablePromise.resolve(promise);
         }
-    }
+    };
     /**
      * @deprecated use {@link fetchIdentifyGeoJson} instead
      */
-    getIdentifyGeoJson(identify, multiple = false) {
+    NgwMap.prototype.getIdentifyGeoJson = function (identify, multiple) {
+        if (multiple === void 0) { 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;
+    };
+    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];
                 }
-            }
-            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;
+            });
+        });
+    };
+    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
      *
@@ -321,131 +426,160 @@ class NgwMap extends WebMap {
      * 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) {
-                    fetchNgwResourceExtent(item, this.connector).then((extent) => {
-                        if (extent) {
-                            this.fitBounds(extent, options);
+    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) {
+                            fetchNgwResourceExtent(item, 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, layerDef, options);
+                        _a.label = 8;
+                    case 8: return [2 /*return*/];
                 }
-            }
-        }
-        else {
-            super.fitLayer(layerDef, options);
-        }
-    }
+            });
+        });
+    };
     /** @deprecated use {@link NgwMap.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);
+    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) {
-            const layerId = this.getLayerId(layer);
+            var layerId = this.getLayerId(layer);
             if (layerId) {
                 delete this._ngwLayers[layerId];
             }
-            super.removeLayer(layer);
+            _super.prototype.removeLayer.call(this, layer);
         }
-    }
-    enableSelection() {
+    };
+    NgwMap.prototype.enableSelection = function () {
+        var _this = this;
         if (!this.$$selectFromNgwRaster) {
-            this.$$selectFromNgwRaster = (ev) => {
-                const count = this.emitter.listenerCount('ngw:select');
+            this.$$selectFromNgwRaster = function (ev) {
+                var count = _this.emitter.listenerCount('ngw:select');
                 if (count) {
-                    this._selectFromNgwRaster(ev);
+                    _this._selectFromNgwRaster(ev);
                 }
             };
-            this.$$selectFromNgwVector = (ev) => {
-                if (this.emitter.listenerCount('ngw:select')) {
-                    this._selectFromNgwVector(ev);
+            this.$$selectFromNgwVector = function (ev) {
+                if (_this.emitter.listenerCount('ngw:select')) {
+                    _this._selectFromNgwVector(ev);
                 }
             };
             this.emitter.on('click', this.$$selectFromNgwRaster);
             this.emitter.on('layer:click', this.$$selectFromNgwVector);
         }
-    }
-    disableSelection() {
+    };
+    NgwMap.prototype.disableSelection = function () {
         if (this.$$selectFromNgwRaster) {
             this.emitter.removeListener('click', this.$$selectFromNgwRaster);
             this.emitter.removeListener('click', this._selectFromNgwVector);
             this.$$selectFromNgwRaster = undefined;
             this.$$selectFromNgwVector = undefined;
         }
-    }
+    };
     /**
      * @deprecated use {@link NgwMap.fetchNgwLayerItem} instead
      */
-    getNgwLayerItem(options) {
+    NgwMap.prototype.getNgwLayerItem = function (options) {
         return this.fetchNgwLayerItem(options);
-    }
+    };
     /**
      * @deprecated use {@link NgwMap.fetchNgwLayerItems} instead
      */
-    getNgwLayerItems(options) {
+    NgwMap.prototype.getNgwLayerItems = function (options) {
         return this.fetchNgwLayerItems(options);
-    }
+    };
     /**
      * @deprecated use {@link NgwMap.fetchNgwLayerFeature} instead
      */
-    getNgwLayerFeature(options) {
+    NgwMap.prototype.getNgwLayerFeature = function (options) {
         return this.fetchNgwLayerFeature(options);
-    }
+    };
     /**
      * @deprecated use {@link NgwMap.fetchNgwLayerFeatures} instead
      */
-    getNgwLayerFeatures(options) {
+    NgwMap.prototype.getNgwLayerFeatures = function (options) {
         return this.fetchNgwLayerFeatures(options);
-    }
+    };
     /** @deprecated use {@link NgwMap.cancelPromises} instead */
-    cancelPromise(...args) {
-        this.cancelPromises(...args);
-    }
-    cancelPromises(...args) {
+    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((name) => {
-            const group = this._promises[name];
+        args.forEach(function (name) {
+            var group = _this._promises[name];
             if (group) {
-                group.forEach((x) => x.cancel());
-                this._promises[name] = [];
+                group.forEach(function (x) { return x.cancel(); });
+                _this._promises[name] = [];
             }
         });
-    }
-    _addPromise(groupName, promise) {
-        const group = this._promises[groupName];
+    };
+    NgwMap.prototype._addPromise = function (groupName, promise) {
+        var group = this._promises[groupName];
         if (group && group.indexOf(promise) === -1) {
-            const removeFromGroup = () => {
-                const index = group.indexOf(promise);
+            var removeFromGroup = function () {
+                var index = group.indexOf(promise);
                 if (index !== -1) {
                     group.splice(index, 1);
                 }
@@ -454,55 +588,78 @@ class NgwMap extends WebMap {
             promise.catch(removeFromGroup);
             group.push(promise);
         }
-    }
-    _isFitFromResource() {
-        const params = this._initMapState;
+    };
+    NgwMap.prototype._isFitFromResource = function () {
+        var 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;
+    };
+    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*/];
                 }
-                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() {
+            });
+        });
+    };
+    NgwMap.prototype._addOsmBaseLayer = function () {
         this.addBaseLayer('OSM');
-    }
-    _addQmsBaseLayer() {
-        let qmsId;
-        let qmsLayerName;
+    };
+    NgwMap.prototype._addQmsBaseLayer = function () {
+        var qmsId;
+        var qmsLayerName;
         if (Array.isArray(this.options.qmsId)) {
             qmsId = this.options.qmsId[0];
             qmsLayerName = this.options.qmsId[1];
@@ -510,135 +667,154 @@ class NgwMap extends WebMap {
         else {
             qmsId = Number(this.options.qmsId);
         }
-        const qmsLayerOptions = {
-            qmsId,
+        var qmsLayerOptions = {
+            qmsId: qmsId,
         };
         if (qmsLayerName) {
             qmsLayerOptions.id = qmsLayerName;
         }
         this.addBaseLayer('QMS', qmsLayerOptions);
-    }
-    _selectFromNgwVector(ev) {
-        const layer = ev.layer;
+    };
+    NgwMap.prototype._selectFromNgwVector = function (ev) {
+        var _a;
+        var layer = ev.layer;
         // item property means layer is NgwResource
-        const id = layer.item && layer.item.resource.id;
-        const feature = ev.feature;
+        var id = layer.item && layer.item.resource.id;
+        var feature = ev.feature;
         if (id !== undefined && feature) {
-            const featureId = feature.id;
+            var featureId = feature.id;
             if (featureId) {
-                const identifyFeature = {
+                var identifyFeature = {
                     id: Number(featureId),
                     fields: feature.properties || {},
-                    label: `#${id}`,
+                    label: "#".concat(id),
                     layerId: Number(id),
                     parent: '',
                     geom: feature.geometry,
                 };
-                const items = {
+                var items = {
                     featureCount: 1,
                     features: [identifyFeature],
                 };
-                const identify = {
-                    featureCount: 1,
-                    [id]: items,
-                };
-                this._emitStatusEvent('ngw:select', this._prepareToIdentify({
-                    ...identify,
-                    resources: [id],
-                    sourceType: 'vector',
-                }));
+                var identify = (_a = {
+                        featureCount: 1
+                    },
+                    _a[id] = items,
+                    _a);
+                this._emitStatusEvent('ngw:select', this._prepareToIdentify(__assign(__assign({}, identify), { resources: [id], sourceType: 'vector' })));
                 return identify;
             }
         }
-    }
-    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;
-        });
-        layers.forEach((l) => {
-            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 = [];
-        getIds.forEach((x) => {
-            if (x) {
-                x.forEach((y) => ids.push(y));
-            }
-        });
-        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) => {
-            this._emitStatusEvent('ngw:select', this._prepareToIdentify({
-                ...resp,
-                resources: ids,
-                sourceType: 'raster',
-                event: ev,
-            }));
-            return resp;
+    };
+    NgwMap.prototype._selectFromNgwRaster = function (ev) {
+        return __awaiter(this, void 0, void 0, function () {
+            var promises, layers, getIdsPromise, getIds, ids, pixelRadius, center, zoom, radius, selectPromise;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.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;
+                        });
+                        layers.forEach(function (l) {
+                            var layer = l.layer;
+                            var 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 = _a.sent();
+                        ids = [];
+                        getIds.forEach(function (x) {
+                            if (x) {
+                                x.forEach(function (y) { return ids.push(y); });
+                            }
+                        });
+                        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) {
+                            _this._emitStatusEvent('ngw:select', _this._prepareToIdentify(__assign(__assign({}, resp), { resources: ids, sourceType: 'raster', event: ev })));
+                            return resp;
+                        });
+                        this._addPromise('select', selectPromise);
+                        return [2 /*return*/, selectPromise];
+                }
+            });
         });
-        this._addPromise('select', selectPromise);
-        return selectPromise;
-    }
-    _prepareToIdentify(identify) {
-        const getIdentifyItems_ = () => {
-            return getIdentifyItems(identify, true).map((x) => {
+    };
+    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,
+                    connector: _this.connector,
                 });
             });
         };
-        return {
-            ...identify,
-            getIdentifyItems: getIdentifyItems_,
-        };
-    }
-    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;
+        return __assign(__assign({}, identify), { getIdentifyItems: getIdentifyItems_ });
+    };
+    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
  */
-async function createNgwMap(options) {
-    const ngwMap = new NgwMap(options);
-    return ngwMap.onLoad();
+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()];
+        });
+    });
 }
 
 export { NgwMap, createNgwMap };