@nextgis/ngw-connector 1.11.3 → 1.12.0

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

@@ -1,49 +1,145 @@
-/** Bundle of @nextgis/ngw-connector; version: 1.11.3; author: NextGIS */
+/** Bundle of @nextgis/ngw-connector; version: 1.12.0; author: NextGIS */
 import { EventEmitter } from 'events';
 import CancelablePromise from '@nextgis/cancelable-promise';
 import { objectDeepEqual, defined, objectRemoveEmpty, fixUrlStr } from '@nextgis/utils';
 import Cache from '@nextgis/cache';
 
+/*! *****************************************************************************
+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 __spreadArray(to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+}
+
 /**
  * Thrown when...
  */
-class NgwError extends Error {
-    constructor(er) {
-        super();
-        this.name = 'NgwError';
-        Object.assign(this, er);
-        Object.setPrototypeOf(this, NgwError.prototype);
+var NgwError = /** @class */ (function (_super) {
+    __extends(NgwError, _super);
+    function NgwError(er) {
+        var _this = _super.call(this) || this;
+        _this.name = 'NgwError';
+        Object.assign(_this, er);
+        Object.setPrototypeOf(_this, NgwError.prototype);
+        return _this;
     }
-}
+    return NgwError;
+}(Error));
 
 /**
  * Thrown when...
  */
-class NetworkError extends Error {
-    constructor(url) {
-        super();
-        this.name = 'NetworkError';
-        Object.setPrototypeOf(this, NetworkError.prototype);
-        this.message = `Unable to request ${url}.
-    Possibly invalid NGW URL entered or CORS not configured to get request from ${location.origin}`; // /control-panel/cors
+var NetworkError = /** @class */ (function (_super) {
+    __extends(NetworkError, _super);
+    function NetworkError(url) {
+        var _this = _super.call(this) || this;
+        _this.name = 'NetworkError';
+        Object.setPrototypeOf(_this, NetworkError.prototype);
+        _this.message = "Unable to request ".concat(url, ".\n    Possibly invalid NGW URL entered or CORS not configured to get request from ").concat(location.origin); // /control-panel/cors
+        return _this;
     }
-}
+    return NetworkError;
+}(Error));
 
 function isObject(val) {
     return Object.prototype.toString.call(val) === '[object Object]';
 }
 
-let loadData;
+var loadData;
 // @ts-ignore
 {
-    loadData = (url, callback, options = {}, error, onCancel) => {
+    loadData = function (url, callback, options, error, onCancel) {
+        if (options === void 0) { options = {}; }
         options.method = options.method || 'GET';
-        const xhr = new XMLHttpRequest();
+        var xhr = new XMLHttpRequest();
         xhr.open(options.method || 'GET', url, true); // true for asynchronous
         if (options.responseType === 'blob') {
             xhr.responseType = options.responseType;
         }
-        const getResponseText = () => {
+        var getResponseText = function () {
             try {
                 return JSON.parse(xhr.responseText);
             }
@@ -51,8 +147,9 @@ let loadData;
                 return xhr.responseText;
             }
         };
-        const processingResponse = (forError = false) => {
-            const cb = forError ? error : callback;
+        var processingResponse = function (forError) {
+            if (forError === void 0) { forError = false; }
+            var cb = forError ? error : callback;
             if (options.responseType === 'blob') {
                 cb(xhr.response);
             }
@@ -65,7 +162,7 @@ let loadData;
                 }
             }
         };
-        xhr.onload = () => {
+        xhr.onload = function () {
             if ([401, 403, 404, 422, 500].indexOf(xhr.status) !== -1) {
                 error(new NgwError(getResponseText()));
             }
@@ -87,7 +184,7 @@ let loadData;
         //     error('request error');
         //   }
         // };
-        xhr.onerror = (er) => {
+        xhr.onerror = function (er) {
             if (xhr.status === 0) {
                 error(new NetworkError(url));
             }
@@ -97,17 +194,17 @@ let loadData;
         };
         xhr.upload.onprogress = function (e) {
             if (e.lengthComputable) {
-                const percentComplete = (e.loaded / e.total) * 100;
+                var percentComplete = (e.loaded / e.total) * 100;
                 if (options.onProgress) {
                     options.onProgress(percentComplete, e);
                 }
                 // console.log(percentComplete + '% uploaded');
             }
         };
-        const headers = options.headers;
+        var headers = options.headers;
         if (headers) {
-            for (const h in headers) {
-                const header = headers[h];
+            for (var h in headers) {
+                var header = headers[h];
                 if (typeof header === 'string') {
                     xhr.setRequestHeader(h, header);
                 }
@@ -116,12 +213,12 @@ let loadData;
         if (options.withCredentials !== undefined) {
             xhr.withCredentials = options.withCredentials;
         }
-        let data;
+        var data;
         if (options.file) {
             data = new FormData();
             data.append('file', options.file);
             if (options.data) {
-                for (const d in options.data) {
+                for (var d in options.data) {
                     data.append(d, data[d]);
                 }
             }
@@ -134,7 +231,7 @@ let loadData;
                 : null;
         }
         if (onCancel) {
-            onCancel(() => {
+            onCancel(function () {
                 xhr.abort();
             });
         }
@@ -143,10 +240,10 @@ let loadData;
 }
 
 // https://github.com/Leaflet/Leaflet/blob/b507e21c510b53cd704fb8d3f89bb46ea925c8eb/src/core/Util.js#L165
-const templateRe = /\{ *([\w_-]+) *\}/g;
+var templateRe = /\{ *([\w_-]+) *\}/g;
 function template(str, data) {
-    return str.replace(templateRe, (s, key) => {
-        let value = data[key];
+    return str.replace(templateRe, function (s, key) {
+        var value = data[key];
         if (value === undefined) {
             throw new Error('No value provided for letiable ' + s);
         }
@@ -160,33 +257,39 @@ function template(str, data) {
 /**
  * Thrown when ...
  */
-class ResourceNotFoundError extends NgwError {
-    constructor(obj) {
-        super(obj);
-        this.name = 'ResourceNotFoundError';
-        this.exception = 'nextgisweb.resource.exception.ResourceNotFound';
-        Object.setPrototypeOf(this, ResourceNotFoundError.prototype);
+var ResourceNotFoundError = /** @class */ (function (_super) {
+    __extends(ResourceNotFoundError, _super);
+    function ResourceNotFoundError(obj) {
+        var _this = _super.call(this, obj) || this;
+        _this.name = 'ResourceNotFoundError';
+        _this.exception = 'nextgisweb.resource.exception.ResourceNotFound';
+        Object.setPrototypeOf(_this, ResourceNotFoundError.prototype);
+        return _this;
     }
-}
+    return ResourceNotFoundError;
+}(NgwError));
 
 /**
  * Thrown when ...
  */
-class InsufficientPermissionsError extends NgwError {
-    constructor(obj) {
-        super(obj);
-        this.name = 'InsufficientPermissionsError';
-        this.exception = 'nextgisweb.core.exception.InsufficientPermissions';
-        Object.setPrototypeOf(this, InsufficientPermissionsError.prototype);
+var InsufficientPermissionsError = /** @class */ (function (_super) {
+    __extends(InsufficientPermissionsError, _super);
+    function InsufficientPermissionsError(obj) {
+        var _this = _super.call(this, obj) || this;
+        _this.name = 'InsufficientPermissionsError';
+        _this.exception = 'nextgisweb.core.exception.InsufficientPermissions';
+        Object.setPrototypeOf(_this, InsufficientPermissionsError.prototype);
+        return _this;
     }
-}
+    return InsufficientPermissionsError;
+}(NgwError));
 
-const CONNECTORS = [];
+var CONNECTORS = [];
 function addConnector(connector) {
     CONNECTORS.push(connector);
 }
 function findConnector(options) {
-    return CONNECTORS.find((x) => {
+    return CONNECTORS.find(function (x) {
         if (x.options.baseUrl === options.baseUrl) {
             if (options.auth) {
                 if (x.options.auth) {
@@ -201,13 +304,13 @@ function findConnector(options) {
     });
 }
 function removeConnector(connector) {
-    const index = CONNECTORS.indexOf(connector);
+    var index = CONNECTORS.indexOf(connector);
     if (index !== -1) {
         CONNECTORS.splice(index, 1);
     }
 }
 
-const exclude = ['description'];
+var exclude = ['description'];
 /**
  * @remarks
  * https://docs.nextgis.ru/docs_ngweb_dev/doc/developer/resource.html#search-resources
@@ -218,14 +321,16 @@ const exclude = ['description'];
  *
  * @param resource - Any property from NGW resource item
  */
-function resourceToQuery(resource, prefix = '') {
+function resourceToQuery(resource, prefix) {
+    if (prefix === void 0) { prefix = ''; }
     prefix = prefix ? prefix + '__' : '';
-    const query = {};
-    for (const [key, value] of Object.entries(resource)) {
+    var query = {};
+    for (var _i = 0, _a = Object.entries(resource); _i < _a.length; _i++) {
+        var _b = _a[_i], key = _b[0], value = _b[1];
         if (exclude.indexOf(key) === -1) {
             if (isObject(value)) {
                 if (key === 'owner_user') {
-                    const children = resourceToQuery(value, key);
+                    var children = resourceToQuery(value, key);
                     Object.assign(query, children);
                 }
                 else if (key === 'parent' && 'id' in value) {
@@ -244,8 +349,8 @@ function resourceCompare(res1, res2) {
     return objectDeepEqual(res1, res2);
 }
 
-class ResourcesControl {
-    constructor(connector) {
+var ResourcesControl = /** @class */ (function () {
+    function ResourcesControl(connector) {
         this.connector = connector;
         this.cache = new Cache();
     }
@@ -259,10 +364,11 @@ class ResourcesControl {
      * @remarks
      * Fetching resource would be cached to speed up next call
      */
-    getOne(resource, requestOptions) {
-        const cache = new Cache();
-        const forCache = {};
-        const opt = { ...requestOptions, cache: false };
+    ResourcesControl.prototype.getOne = function (resource, requestOptions) {
+        var _this = this;
+        var cache = new Cache();
+        var forCache = {};
+        var opt = __assign(__assign({}, requestOptions), { cache: false });
         if (typeof resource === 'string') {
             forCache.keyname = resource;
         }
@@ -272,28 +378,28 @@ class ResourcesControl {
         else if (isObject(resource)) {
             forCache.id = resource.id;
         }
-        const makeRequest = () => {
+        var makeRequest = function () {
             if (typeof resource === 'string') {
-                return this._fetchResourceBy({ keyname: resource }, opt);
+                return _this._fetchResourceBy({ keyname: resource }, opt);
             }
             else if (typeof resource === 'number') {
-                return this._fetchResourceById(resource, opt);
+                return _this._fetchResourceById(resource, opt);
             }
             else if (isObject(resource)) {
-                return this._fetchResourceBy(resource, opt);
+                return _this._fetchResourceBy(resource, opt);
             }
             return CancelablePromise.resolve(undefined);
         };
         return cache.addFull('resource', makeRequest, forCache);
-    }
-    getOneOrFail(resource, requestOptions) {
-        return this.getOne(resource, requestOptions).then((res) => {
+    };
+    ResourcesControl.prototype.getOneOrFail = function (resource, requestOptions) {
+        return this.getOne(resource, requestOptions).then(function (res) {
             if (res) {
                 return res;
             }
             throw new ResourceNotFoundError();
         });
-    }
+    };
     /**
      * A fast way to retrieve resource ID for any resource definition.
      * @param resource - Any available resource definition
@@ -304,19 +410,19 @@ class ResourcesControl {
      * then this method will come in handy to facilitate the extraction of the identifier
      * if the resource is specified through a keyname or other parameters.
      */
-    getId(resource, requestOptions) {
+    ResourcesControl.prototype.getId = function (resource, requestOptions) {
         if (typeof resource === 'number') {
             return CancelablePromise.resolve(resource);
         }
         else if (typeof resource === 'string' || isObject(resource)) {
-            return this.getOne(resource, requestOptions).then((res) => {
+            return this.getOne(resource, requestOptions).then(function (res) {
                 if (res) {
                     return res.resource.id;
                 }
             });
         }
         return CancelablePromise.resolve(undefined);
-    }
+    };
     /**
      * A fast way to retrieve resource ID for any resource definition.
      * @param resource - Any available resource definition
@@ -325,33 +431,32 @@ class ResourcesControl {
      * Similar with {@link NgwConnector.getResourceId | getResourceId} but rise error if resource is not exist.
      * To not make one more checks if the resource is definitely exists
      */
-    getIdOrFail(resource, requestOptions) {
-        return this.getId(resource, requestOptions).then((resp) => {
+    ResourcesControl.prototype.getIdOrFail = function (resource, requestOptions) {
+        return this.getId(resource, requestOptions).then(function (resp) {
             if (resp === undefined) {
                 throw new Error();
             }
             return resp;
         });
-    }
-    getMany(resource, requestOptions) {
-        return this._resourceCacheFilter(resource).then((items) => {
+    };
+    ResourcesControl.prototype.getMany = function (resource, requestOptions) {
+        var _this = this;
+        return this._resourceCacheFilter(resource).then(function (items) {
             if (!items.length) {
-                const query = {};
+                var query = {};
                 if (resource.keyname) {
                     query.keyname = resource.keyname;
                 }
                 else {
                     Object.assign(query, resourceToQuery(resource));
                 }
-                return this.connector
-                    .get('resource.search', requestOptions, {
-                    serialization: 'full',
-                    ...query,
-                })
-                    .then((resources) => {
+                return _this.connector
+                    .get('resource.search', requestOptions, __assign({ serialization: 'full' }, query))
+                    .then(function (resources) {
                     if (resources) {
-                        for (const x of resources) {
-                            this.cache.add('resource.item', CancelablePromise.resolve(x), {
+                        for (var _i = 0, resources_1 = resources; _i < resources_1.length; _i++) {
+                            var x = resources_1[_i];
+                            _this.cache.add('resource.item', CancelablePromise.resolve(x), {
                                 id: x.resource.id,
                             });
                         }
@@ -361,97 +466,122 @@ class ResourcesControl {
             }
             return items;
         });
-    }
-    getParent(resource, requestOptions) {
-        return this.getOne(resource, requestOptions).then((child) => {
+    };
+    ResourcesControl.prototype.getParent = function (resource, requestOptions) {
+        var _this = this;
+        return this.getOne(resource, requestOptions).then(function (child) {
             if (child) {
-                return this.getOne(child.resource.parent.id, requestOptions);
+                return _this.getOne(child.resource.parent.id, requestOptions);
             }
             return CancelablePromise.resolve(undefined);
         });
-    }
-    getChildrenOf(resource, requestOptions) {
-        return this.getId(resource).then((parent) => {
-            return this.connector
-                .get('resource.collection', { cache: true, ...requestOptions }, {
-                parent,
+    };
+    ResourcesControl.prototype.getChildrenOf = function (resource, requestOptions) {
+        var _this = this;
+        return this.getId(resource).then(function (parent) {
+            return _this.connector
+                .get('resource.collection', __assign({ cache: true }, requestOptions), {
+                parent: parent,
             })
-                .then((items) => {
-                for (const i of items) {
-                    this.cache.add('resource.item', CancelablePromise.resolve(i), {
+                .then(function (items) {
+                for (var _i = 0, items_1 = items; _i < items_1.length; _i++) {
+                    var i = items_1[_i];
+                    _this.cache.add('resource.item', CancelablePromise.resolve(i), {
                         id: i.resource.id,
                     });
                 }
                 return items;
             });
         });
-    }
-    update(resource, data) {
-        return this.getId(resource).then((id) => {
+    };
+    ResourcesControl.prototype.update = function (resource, data) {
+        var _this = this;
+        return this.getId(resource).then(function (id) {
             if (id !== undefined) {
-                return this.connector.put('resource.item', { data }, { id });
+                return _this.connector.put('resource.item', { data: data }, { id: id });
             }
         });
-    }
+    };
     /**
      * Fast way to delete resource from NGW and clean cache.
      * @param resource - Resource definition
      */
-    delete(resource) {
-        return this.getId(resource).then((id) => {
+    ResourcesControl.prototype.delete = function (resource) {
+        var _this = this;
+        return this.getId(resource).then(function (id) {
             if (id !== undefined) {
-                return this.connector.delete('resource.item', null, { id }).then(() => {
-                    this._cleanResourceItemCache(id);
+                return _this.connector.delete('resource.item', null, { id: id }).then(function () {
+                    _this._cleanResourceItemCache(id);
                     return undefined;
                 });
             }
         });
-    }
-    async _cleanResourceItemCache(id) {
-        const all = this.cache.all();
-        const toDelete = [];
-        for (const c of all) {
-            const cid = c.options && c.options.id;
-            if (['resource.item', 'resource'].includes(c.key) && cid !== undefined) {
-                if (typeof cid === 'number') {
-                    if (cid === id) {
-                        toDelete.push(c);
-                    }
-                }
-                else {
-                    const rid = await this.getId(cid);
-                    if (rid === id) {
-                        toDelete.push(c);
-                    }
+    };
+    ResourcesControl.prototype._cleanResourceItemCache = function (id) {
+        return __awaiter(this, void 0, void 0, function () {
+            var all, toDelete, _i, all_1, c, cid, rid, _a, toDelete_1, d;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        all = this.cache.all();
+                        toDelete = [];
+                        _i = 0, all_1 = all;
+                        _b.label = 1;
+                    case 1:
+                        if (!(_i < all_1.length)) return [3 /*break*/, 5];
+                        c = all_1[_i];
+                        cid = c.options && c.options.id;
+                        if (!(['resource.item', 'resource'].includes(c.key) && cid !== undefined)) return [3 /*break*/, 4];
+                        if (!(typeof cid === 'number')) return [3 /*break*/, 2];
+                        if (cid === id) {
+                            toDelete.push(c);
+                        }
+                        return [3 /*break*/, 4];
+                    case 2: return [4 /*yield*/, this.getId(cid)];
+                    case 3:
+                        rid = _b.sent();
+                        if (rid === id) {
+                            toDelete.push(c);
+                        }
+                        _b.label = 4;
+                    case 4:
+                        _i++;
+                        return [3 /*break*/, 1];
+                    case 5:
+                        for (_a = 0, toDelete_1 = toDelete; _a < toDelete_1.length; _a++) {
+                            d = toDelete_1[_a];
+                            this.cache.delete(d);
+                        }
+                        return [2 /*return*/];
                 }
-            }
-        }
-        for (const d of toDelete) {
-            this.cache.delete(d);
-        }
-    }
-    _fetchResourceById(id, requestOptions) {
-        const promise = () => this.connector.get('resource.item', requestOptions, { id });
+            });
+        });
+    };
+    ResourcesControl.prototype._fetchResourceById = function (id, requestOptions) {
+        var _this = this;
+        var promise = function () {
+            return _this.connector.get('resource.item', requestOptions, { id: id });
+        };
         return this.cache
             .add('resource.item', promise, {
-            id,
+            id: id,
         })
-            .catch((er) => {
+            .catch(function (er) {
             if (!(er instanceof ResourceNotFoundError)) {
                 throw er;
             }
             return undefined;
         });
-    }
-    _fetchResourceBy(resource, requestOptions) {
-        return this.getMany(resource, requestOptions).then((resources) => {
+    };
+    ResourcesControl.prototype._fetchResourceBy = function (resource, requestOptions) {
+        return this.getMany(resource, requestOptions).then(function (resources) {
             return resources[0];
         });
-    }
-    _resourceCacheFilter(resource) {
-        return CancelablePromise.all(this.cache.matchAll('resource.item')).then((resources) => {
-            const items = [];
-            resources.filter((x) => {
+    };
+    ResourcesControl.prototype._resourceCacheFilter = function (resource) {
+        return CancelablePromise.all(this.cache.matchAll('resource.item')).then(function (resources) {
+            var items = [];
+            resources.filter(function (x) {
                 if (x) {
                     // identical by uniq props
                     if (resource.keyname && x.resource.keyname) {
@@ -465,23 +595,24 @@ class ResourcesControl {
             });
             return items;
         });
-    }
-}
+    };
+    return ResourcesControl;
+}());
 
 function apiRequest(opt) {
-    const params = opt.params;
-    return new CancelablePromise((resolve, reject) => {
+    var params = opt.params;
+    return new CancelablePromise(function (resolve, reject) {
         opt.connector
             .connect()
-            .then((apiItems) => {
-            let apiItem = apiItems && apiItems[opt.name];
+            .then(function (apiItems) {
+            var apiItem = apiItems && apiItems[opt.name];
             if (apiItem) {
-                apiItem = [...apiItem];
-                let url = apiItem.shift();
+                apiItem = __spreadArray([], apiItem, true);
+                var url = apiItem.shift();
                 if (apiItem.length) {
-                    const replaceParams = {};
-                    for (let fry = 0; fry < apiItem.length; fry++) {
-                        const arg = apiItem[fry];
+                    var replaceParams = {};
+                    for (var fry = 0; fry < apiItem.length; fry++) {
+                        var arg = apiItem[fry];
                         replaceParams[fry] = '{' + arg + '}';
                         if (params[arg] === undefined) {
                             throw new Error('`' + arg + '`' + ' url api argument is not specified');
@@ -493,21 +624,21 @@ function apiRequest(opt) {
                 }
                 // Transfer part of the parameters from `params` to the URL string
                 if (params) {
-                    const paramArray = [];
-                    const paramList = params.paramList;
+                    var paramArray_1 = [];
+                    var paramList = params.paramList;
                     if (Array.isArray(paramList)) {
                         delete params.paramList;
-                        paramList.forEach((x) => {
-                            paramArray.push(`${x[0]}=${x[1]}`);
+                        paramList.forEach(function (x) {
+                            paramArray_1.push("".concat(x[0], "=").concat(x[1]));
                         });
                     }
-                    for (const p in params) {
+                    for (var p in params) {
                         if (apiItem.indexOf(p) === -1) {
-                            paramArray.push(`${p}=${params[p]}`);
+                            paramArray_1.push("".concat(p, "=").concat(params[p]));
                         }
                     }
-                    if (paramArray.length) {
-                        url = url + '?' + paramArray.join('&');
+                    if (paramArray_1.length) {
+                        url = url + '?' + paramArray_1.join('&');
                     }
                 }
                 if (url) {
@@ -521,20 +652,20 @@ function apiRequest(opt) {
                 resolve(undefined);
             }
         })
-            .catch((er) => {
+            .catch(function (er) {
             reject(er);
         });
     });
 }
 
-let ID = 0;
-class NgwConnector$1 {
-    constructor(options) {
+var ID = 0;
+var NgwConnector$1 = /** @class */ (function () {
+    function NgwConnector(options) {
         this.options = options;
         this.id = ID++;
         this.emitter = new EventEmitter();
         this.routeStr = '/api/component/pyramid/route';
-        const exist = findConnector(options);
+        var exist = findConnector(options);
         if (exist) {
             return exist;
         }
@@ -546,19 +677,19 @@ class NgwConnector$1 {
             addConnector(this);
         }
     }
-    static create(options) {
+    NgwConnector.create = function (options) {
         return new this(options);
-    }
+    };
     /**
      * Fast way to specify the connection address to NextGIS Web.
      * The current connection will be severed.
      * @param baseUrl - NGW url
      */
-    setNgw(baseUrl) {
+    NgwConnector.prototype.setNgw = function (baseUrl) {
         this.logout();
         this.options.baseUrl = baseUrl;
         addConnector(this);
-    }
+    };
     /**
      * Establishing a connection with NextGIS Web to fulfill all other requests.
      * @remarks
@@ -572,101 +703,105 @@ class NgwConnector$1 {
      *   .catch((er) => console.log('Connection problem', er));
      * ```
      */
-    connect() {
-        const cache = new Cache();
-        const auth = this.options.auth;
-        const makeConnect = () => new CancelablePromise((resolve, reject) => {
-            const makeQuery = () => {
-                return this.makeQuery(this.routeStr, {}, {})
-                    .then((route) => {
-                    resolve(route);
-                })
-                    .catch((er) => {
-                    reject(er);
-                });
-            };
-            if (auth) {
-                const { login, password } = auth;
-                if (login && password) {
-                    return this.getUserInfo({ login, password })
-                        .then(() => {
-                        makeQuery();
+    NgwConnector.prototype.connect = function () {
+        var _this = this;
+        var cache = new Cache();
+        var auth = this.options.auth;
+        var makeConnect = function () {
+            return new CancelablePromise(function (resolve, reject) {
+                var makeQuery = function () {
+                    return _this.makeQuery(_this.routeStr, {}, {})
+                        .then(function (route) {
+                        resolve(route);
                     })
-                        .catch((er) => reject(er));
+                        .catch(function (er) {
+                        reject(er);
+                    });
+                };
+                if (auth) {
+                    var login = auth.login, password = auth.password;
+                    if (login && password) {
+                        return _this.getUserInfo({ login: login, password: password })
+                            .then(function () {
+                            makeQuery();
+                        })
+                            .catch(function (er) { return reject(er); });
+                    }
                 }
-            }
-            return makeQuery();
-        });
+                return makeQuery();
+            });
+        };
         return cache.add('route', makeConnect, {
             id: this.id,
-            auth,
+            auth: auth,
             baseUrl: this.options.baseUrl,
         });
-    }
+    };
     /**
      * Quick way to change NextGIS Web user.
      * @param credentials - New user credentials
      */
-    login(credentials) {
+    NgwConnector.prototype.login = function (credentials) {
         this.logout();
         addConnector(this);
         return this.getUserInfo(credentials);
-    }
+    };
     /**
      * Disconnecting a user. Aborting all current requests
      */
-    logout() {
+    NgwConnector.prototype.logout = function () {
         removeConnector(this);
         this.options.auth = undefined;
         this.user = undefined;
         this.emitter.emit('logout');
         this.resources.cache.clean();
-    }
-    getUserInfo(credentials) {
+    };
+    NgwConnector.prototype.getUserInfo = function (credentials) {
+        var _this = this;
         if (this.user && this.user.id) {
             return CancelablePromise.resolve(this.user);
         }
         if (credentials) {
             this.options.auth = credentials;
         }
-        const options = {
+        var options = {
             headers: this.getAuthorizationHeaders(credentials),
             // withCredentials: true
         };
         // Do not use apiRequest('auth.current_user') to avoid circular-references
         return this.makeQuery('/api/component/auth/current_user', {}, options)
-            .then((data) => {
-            this.user = data;
-            this.emitter.emit('login', data);
+            .then(function (data) {
+            _this.user = data;
+            _this.emitter.emit('login', data);
             return data;
         })
-            .catch((er) => {
-            this.emitter.emit('login:error', er);
+            .catch(function (er) {
+            _this.emitter.emit('login:error', er);
             throw er;
         });
-    }
+    };
     /**
      * Obtaining the required Headers for authentication of requests in the NGW.
      */
-    getAuthorizationHeaders(credentials) {
-        const client = this.makeClientId(credentials);
+    NgwConnector.prototype.getAuthorizationHeaders = function (credentials) {
+        var client = this.makeClientId(credentials);
         if (client) {
             return {
                 Authorization: 'Basic ' + client,
             };
         }
-    }
-    makeClientId(credentials) {
+    };
+    NgwConnector.prototype.makeClientId = function (credentials) {
         credentials = credentials || this.options.auth;
         if (credentials) {
-            const { login, password } = credentials;
-            const str = unescape(encodeURIComponent(`${login}:${password}`));
+            var login = credentials.login, password = credentials.password;
+            var str = unescape(encodeURIComponent("".concat(login, ":").concat(password)));
             // @ts-ignore
             {
                 return window.btoa(str);
             }
         }
-    }
+    };
     /**
      * Send request to NGW api router.
      * @param name - NGW route name from {@link https://docs.nextgis.com/docs_ngweb_dev/doc/developer/resource.html#routes | routes}
@@ -696,25 +831,27 @@ class NgwConnector$1 {
      *
      * ```
      */
-    apiRequest(name, params_ = {}, requestOptions = {}) {
-        const { method, headers, withCredentials, responseType } = requestOptions;
-        const params = objectRemoveEmpty(params_);
-        const makeApiRequest = () => apiRequest({ name, params, requestOptions, connector: this });
+    NgwConnector.prototype.apiRequest = function (name, params_, requestOptions) {
+        var _this = this;
+        if (params_ === void 0) { params_ = {}; }
+        if (requestOptions === void 0) { requestOptions = {}; }
+        var method = requestOptions.method, headers = requestOptions.headers, withCredentials = requestOptions.withCredentials, responseType = requestOptions.responseType;
+        var params = objectRemoveEmpty(params_);
+        var makeApiRequest = function () {
+            return apiRequest({ name: name, params: params, requestOptions: requestOptions, connector: _this });
+        };
         if (requestOptions.cache && method === 'GET') {
-            const cache = new Cache();
-            return cache.add(name, makeApiRequest, {
-                params,
-                ...objectRemoveEmpty({
-                    headers,
-                    withCredentials,
-                    responseType,
-                    baseUrl: this.options.baseUrl,
-                    auth: this.options.auth,
-                }),
-            });
+            var cache = new Cache();
+            return cache.add(name, makeApiRequest, __assign({ params: params }, objectRemoveEmpty({
+                headers: headers,
+                withCredentials: withCredentials,
+                responseType: responseType,
+                baseUrl: this.options.baseUrl,
+                auth: this.options.auth,
+            })));
         }
         return makeApiRequest();
-    }
+    };
     /**
      * Shortcut method for send POST request to NGW.
      * @param name - NGW route name from {@link https://docs.nextgis.com/docs_ngweb_dev/doc/developer/resource.html#routes | routes}
@@ -728,62 +865,63 @@ class NgwConnector$1 {
      *   .catch((error) => console.warn(error));
      * ```
      */
-    post(name, options, params) {
+    NgwConnector.prototype.post = function (name, options, params) {
         options = options || {};
         options.method = 'POST';
         return this.apiRequest(name, params, options);
-    }
+    };
     /**
      * Shortcut method for send GET request to NGW.
      * @param name - NGW route name from {@link https://docs.nextgis.com/docs_ngweb_dev/doc/developer/resource.html#routes | routes}
      * @param options - Request options
      * @param params - Request item params or query params
      */
-    get(name, options, params) {
+    NgwConnector.prototype.get = function (name, options, params) {
         options = options || {};
         options.method = 'GET';
         return this.apiRequest(name, params, options);
-    }
+    };
     /**
      * Shortcut method for send PATCH request to NGW.
      * @param name - NGW route name from {@link https://docs.nextgis.com/docs_ngweb_dev/doc/developer/resource.html#routes | routes}
      * @param options - Request options
      * @param params - Request item params or query params
      */
-    patch(name, options, params) {
+    NgwConnector.prototype.patch = function (name, options, params) {
         options = options || {};
         options.method = 'PATCH';
         return this.apiRequest(name, params, options);
-    }
+    };
     /**
      * Shortcut method for send PUT request to NGW.
      * @param name - NGW route name from {@link https://docs.nextgis.com/docs_ngweb_dev/doc/developer/resource.html#routes | routes}
      * @param options - Request options
      * @param params - Request item params or query params
      */
-    put(name, options, params) {
+    NgwConnector.prototype.put = function (name, options, params) {
         options = options || {};
         options.method = 'PUT';
         return this.apiRequest(name, params, options);
-    }
+    };
     /**
      * Shortcut method for send DELETE request to NGW.
      * @param name - NGW route name from {@link https://docs.nextgis.com/docs_ngweb_dev/doc/developer/resource.html#routes | routes}
      * @param options - Request options
      * @param params - Request item params or query params
      */
-    delete(name, options, params) {
+    NgwConnector.prototype.delete = function (name, options, params) {
         options = options || {};
         options.method = 'DELETE';
         return this.apiRequest(name, params, options);
-    }
+    };
     /**
      * Send request to NGW.
      * @param url - URL address to NGW
      * @param params - Query params
      * @param options - Request options
      */
-    makeQuery(url, params, options = {}) {
+    NgwConnector.prototype.makeQuery = function (url, params, options) {
+        if (options === void 0) { options = {}; }
         url = (this.options.baseUrl ? this.options.baseUrl : '') + url;
         if (url) {
             if (params) {
@@ -796,112 +934,110 @@ class NgwConnector$1 {
         else {
             throw new Error('Empty `url` not allowed');
         }
-    }
+    };
     // -------------------------------------------------------------------------
     // Resource Methods
     // -------------------------------------------------------------------------
     /**
      * {@inheritDoc ResourcesControl.getOne}
      */
-    getResource(resource, requestOptions) {
+    NgwConnector.prototype.getResource = function (resource, requestOptions) {
         return this.resources.getOne(resource, requestOptions);
-    }
+    };
     /**
      * {@inheritDoc ResourcesControl.getOneOrFail}
      */
-    getResourceOrFail(resource, requestOptions) {
+    NgwConnector.prototype.getResourceOrFail = function (resource, requestOptions) {
         return this.resources.getOneOrFail(resource, requestOptions);
-    }
+    };
     /**
      * @deprecated - use {@link NgwConnector.getResource}
      */
-    getResourceBy(resource) {
+    NgwConnector.prototype.getResourceBy = function (resource) {
         return this.resources.getOne(resource);
-    }
+    };
     /**
      * @deprecated - use {@link NgwConnector.getResource}
      */
-    getResourceByKeyname(keyname) {
+    NgwConnector.prototype.getResourceByKeyname = function (keyname) {
         return this.resources.getOne(keyname);
-    }
+    };
     /**
      * @deprecated - use {@link NgwConnector.getResource}
      */
-    getResourceById(id) {
+    NgwConnector.prototype.getResourceById = function (id) {
         return this.resources.getOne(id);
-    }
+    };
     /**
      * {@inheritDoc ResourcesControl.getId}
      */
-    getResourceId(resource, requestOptions) {
+    NgwConnector.prototype.getResourceId = function (resource, requestOptions) {
         return this.resources.getId(resource, requestOptions);
-    }
+    };
     /**
      * {@inheritDoc ResourcesControl.getIdOrFail}
      */
-    getResourceIdOrFail(resource, requestOptions) {
+    NgwConnector.prototype.getResourceIdOrFail = function (resource, requestOptions) {
         return this.resources.getIdOrFail(resource, requestOptions);
-    }
+    };
     /**
      * {@inheritDoc ResourcesControl.getMany}
      */
-    getResourcesBy(resource, requestOptions) {
+    NgwConnector.prototype.getResourcesBy = function (resource, requestOptions) {
         return this.resources.getMany(resource, requestOptions);
-    }
+    };
     /**
      * {@inheritDoc ResourcesControl.getParent}
      */
-    getResourceParent(resource, requestOptions) {
+    NgwConnector.prototype.getResourceParent = function (resource, requestOptions) {
         return this.resources.getParent(resource, requestOptions);
-    }
+    };
     /**
      * {@inheritDoc ResourcesControl.getChildrenOf}
      */
-    getResourceChildren(resource, requestOptions) {
+    NgwConnector.prototype.getResourceChildren = function (resource, requestOptions) {
         return this.resources.getChildrenOf(resource, requestOptions);
-    }
+    };
     /**
      * {@inheritDoc ResourcesControl.update}
      */
-    updateResource(resource, data) {
+    NgwConnector.prototype.updateResource = function (resource, data) {
         return this.resources.update(resource, data);
-    }
+    };
     /**
      * {@inheritDoc ResourcesControl.delete}
      */
-    deleteResource(resource) {
+    NgwConnector.prototype.deleteResource = function (resource) {
         return this.resources.delete(resource);
-    }
+    };
     /**
      * @internal
      */
-    _loadData(url, options) {
+    NgwConnector.prototype._loadData = function (url, options) {
+        var _this = this;
         options.responseType = options.responseType || 'json';
-        return new CancelablePromise((resolve, reject, onCancel) => {
-            if (this.user) {
+        return new CancelablePromise(function (resolve, reject, onCancel) {
+            if (_this.user) {
                 options = options || {};
                 // options.withCredentials = true;
-                options.headers = {
-                    ...this.getAuthorizationHeaders(),
-                    ...options.headers,
-                };
+                options.headers = __assign(__assign({}, _this.getAuthorizationHeaders()), options.headers);
             }
             loadData(url, resolve, options, reject, onCancel);
-        }).catch((httpError) => {
+        }).catch(function (httpError) {
             if (httpError instanceof CancelablePromise.CancelError) ;
             else {
                 // @ts-ignore
                 if ((process.env.NODE_ENV !== 'production')) {
                     console.warn('DEV WARN', httpError);
                 }
-                const er = this._handleHttpError(httpError);
+                var er = _this._handleHttpError(httpError);
                 if (er) {
                     throw er;
                 }
             }
         });
-    }
-    _handleHttpError(er) {
+    };
+    NgwConnector.prototype._handleHttpError = function (er) {
         if (er) {
             if (er instanceof NgwError) {
                 if (er.exception === 'nextgisweb.resource.exception.ResourceNotFound') {
@@ -913,12 +1049,13 @@ class NgwConnector$1 {
             }
         }
         return er;
-    }
-}
-NgwConnector$1.errors = {
-    NgwError,
-    ResourceNotFoundError,
-};
+    };
+    NgwConnector.errors = {
+        NgwError: NgwError,
+        ResourceNotFoundError: ResourceNotFoundError,
+    };
+    return NgwConnector;
+}());
 
 /**
  * A lightweight HTTP client optimized for use with {@link http://docs.nextgis.ru/docs_ngweb_dev/doc/developer/toc.html | NextGIS Web} API