@nextgis/ngw-connector 1.11.10 → 1.12.0

package/lib/ngw-connector.cjs.js

@@ -1,4 +1,4 @@
-/** Bundle of @nextgis/ngw-connector; version: 1.11.10; author: NextGIS */
+/** Bundle of @nextgis/ngw-connector; version: 1.12.0; author: NextGIS */
 'use strict';
 
 var events = require('events');
@@ -11,73 +11,176 @@ function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'defau
 var CancelablePromise__default = /*#__PURE__*/_interopDefaultLegacy(CancelablePromise);
 var Cache__default = /*#__PURE__*/_interopDefaultLegacy(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 __rest(s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+}
+
+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));
 
 function isObject(val) {
     return Object.prototype.toString.call(val) === '[object Object]';
 }
 
-let loadData;
+var loadData;
 // @ts-ignore
 {
-    const url = require('url');
-    const http = require('http');
-    const https = require('https');
-    const FormData = require('form-data');
-    const adapterFor = (inputUrl) => {
-        const adapters = {
-            'http:': http,
-            'https:': https,
+    var url_1 = require('url');
+    var http_1 = require('http');
+    var https_1 = require('https');
+    var FormData_1 = require('form-data');
+    var adapterFor_1 = function (inputUrl) {
+        var adapters = {
+            'http:': http_1,
+            'https:': https_1,
         };
-        const protocol = url.parse(inputUrl).protocol || 'https:';
+        var protocol = url_1.parse(inputUrl).protocol || 'https:';
         return adapters[protocol];
     };
-    loadData = (url, callback, options = {}, error, onCancel) => {
-        const { file, headers, method, data, responseType } = options;
-        const request = new Promise((resolve, reject) => {
-            const adapter = adapterFor(url);
+    loadData = function (url, callback, options, error, onCancel) {
+        if (options === void 0) { options = {}; }
+        var file = options.file, headers = options.headers, method = options.method, data = options.data, responseType = options.responseType;
+        var request = new Promise(function (resolve, reject) {
+            var adapter = adapterFor_1(url);
             if (adapter) {
-                const requestOpt = {
+                var requestOpt = {
                     headers: headers || {},
-                    method,
+                    method: method,
                 };
-                const body = typeof data === 'string' ? data : JSON.stringify(data);
+                var body = typeof data === 'string' ? data : JSON.stringify(data);
                 // https://stackoverflow.com/questions/35589109/node-http-delete-request-no-longer-works-after-upgrading-from-0-10-40
-                let form;
-                let uploadedFile = file;
+                var form = void 0;
+                var uploadedFile = file;
                 if (file) {
-                    const fileMeta = {};
+                    var fileMeta = {};
                     if (isObject(file) &&
                         'file' in file &&
                         ('filename' in file || 'name' in file)) {
-                        const { file: file_, name, ...fileMeta_ } = file;
-                        if (name && !fileMeta_.filename) {
-                            fileMeta_.filename = name;
+                        var _a = file, file_ = _a.file, name_1 = _a.name, fileMeta_ = __rest(_a, ["file", "name"]);
+                        if (name_1 && !fileMeta_.filename) {
+                            fileMeta_.filename = name_1;
                         }
                         Object.assign(fileMeta, fileMeta_);
                         uploadedFile = file_;
                     }
-                    form = new FormData();
+                    form = new FormData_1();
                     form.append('file', uploadedFile, fileMeta);
                     if (data) {
-                        for (const d in data) {
+                        for (var d in data) {
                             form.append(d, data[d]);
                         }
                     }
-                    Object.assign(requestOpt.headers, {
-                        // 'content-length': form.getLengthSync(),
-                        ...form.getHeaders(),
-                    });
+                    Object.assign(requestOpt.headers, __assign({}, form.getHeaders()));
                 }
                 if (body !== undefined && method !== 'POST') {
                     Object.assign(requestOpt.headers, {
@@ -85,18 +188,18 @@ let loadData;
                         'content-length': Buffer.byteLength(body),
                     });
                 }
-                const req = adapter.request(url, requestOpt, (resp) => {
-                    let data = '';
-                    resp.on('data', (chunk) => {
+                var req_1 = adapter.request(url, requestOpt, function (resp) {
+                    var data = '';
+                    resp.on('data', function (chunk) {
                         data += chunk;
                     });
-                    resp.on('end', () => {
+                    resp.on('end', function () {
                         if (data) {
                             if (responseType === 'blob') {
                                 resolve(data);
                             }
                             else {
-                                let json;
+                                var json = void 0;
                                 try {
                                     json = JSON.parse(data);
                                     if (json && json.status_code && json.status_code) {
@@ -116,31 +219,31 @@ let loadData;
                     });
                 });
                 if (form) {
-                    form.pipe(req);
+                    form.pipe(req_1);
                 }
-                req.on('error', (err) => {
+                req_1.on('error', function (err) {
                     reject(err);
                 });
                 if (body) {
-                    req.write(body);
+                    req_1.write(body);
                 }
-                onCancel(() => {
-                    req.abort();
+                onCancel(function () {
+                    req_1.abort();
                 });
-                req.end();
+                req_1.end();
             }
             else {
-                throw new Error(`Given URL '${url}' is not correct`);
+                throw new Error("Given URL '".concat(url, "' is not correct"));
             }
         });
         return request
-            .then((data) => {
+            .then(function (data) {
             if (callback) {
                 callback(data);
             }
             return data;
         })
-            .catch((er) => {
+            .catch(function (er) {
             if (error) {
                 error(er);
             }
@@ -152,10 +255,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);
         }
@@ -169,33 +272,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) {
@@ -210,13 +319,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
@@ -227,14 +336,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) {
@@ -253,8 +364,8 @@ function resourceCompare(res1, res2) {
     return utils.objectDeepEqual(res1, res2);
 }
 
-class ResourcesControl {
-    constructor(connector) {
+var ResourcesControl = /** @class */ (function () {
+    function ResourcesControl(connector) {
         this.connector = connector;
         this.cache = new Cache__default();
     }
@@ -268,10 +379,11 @@ class ResourcesControl {
      * @remarks
      * Fetching resource would be cached to speed up next call
      */
-    getOne(resource, requestOptions) {
-        const cache = new Cache__default();
-        const forCache = {};
-        const opt = { ...requestOptions, cache: false };
+    ResourcesControl.prototype.getOne = function (resource, requestOptions) {
+        var _this = this;
+        var cache = new Cache__default();
+        var forCache = {};
+        var opt = __assign(__assign({}, requestOptions), { cache: false });
         if (typeof resource === 'string') {
             forCache.keyname = resource;
         }
@@ -281,28 +393,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__default.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
@@ -313,19 +425,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__default.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__default.resolve(undefined);
-    }
+    };
     /**
      * A fast way to retrieve resource ID for any resource definition.
      * @param resource - Any available resource definition
@@ -334,33 +446,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__default.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__default.resolve(x), {
                                 id: x.resource.id,
                             });
                         }
@@ -370,97 +481,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__default.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__default.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__default.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__default.all(this.cache.matchAll('resource.item')).then((resources) => {
-            const items = [];
-            resources.filter((x) => {
+    };
+    ResourcesControl.prototype._resourceCacheFilter = function (resource) {
+        return CancelablePromise__default.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) {
@@ -474,23 +610,24 @@ class ResourcesControl {
             });
             return items;
         });
-    }
-}
+    };
+    return ResourcesControl;
+}());
 
 function apiRequest(opt) {
-    const params = opt.params;
-    return new CancelablePromise__default((resolve, reject) => {
+    var params = opt.params;
+    return new CancelablePromise__default(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');
@@ -502,21 +639,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) {
@@ -530,20 +667,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 events.EventEmitter();
         this.routeStr = '/api/component/pyramid/route';
-        const exist = findConnector(options);
+        var exist = findConnector(options);
         if (exist) {
             return exist;
         }
@@ -555,19 +692,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
@@ -581,101 +718,105 @@ class NgwConnector$1 {
      *   .catch((er) => console.log('Connection problem', er));
      * ```
      */
-    connect() {
-        const cache = new Cache__default();
-        const auth = this.options.auth;
-        const makeConnect = () => new CancelablePromise__default((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__default();
+        var auth = this.options.auth;
+        var makeConnect = function () {
+            return new CancelablePromise__default(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__default.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 Buffer.from(str).toString('base64');
             }
         }
-    }
+    };
     /**
      * 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}
@@ -705,25 +846,27 @@ class NgwConnector$1 {
      *
      * ```
      */
-    apiRequest(name, params_ = {}, requestOptions = {}) {
-        const { method, headers, withCredentials, responseType } = requestOptions;
-        const params = utils.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 = utils.objectRemoveEmpty(params_);
+        var makeApiRequest = function () {
+            return apiRequest({ name: name, params: params, requestOptions: requestOptions, connector: _this });
+        };
         if (requestOptions.cache && method === 'GET') {
-            const cache = new Cache__default();
-            return cache.add(name, makeApiRequest, {
-                params,
-                ...utils.objectRemoveEmpty({
-                    headers,
-                    withCredentials,
-                    responseType,
-                    baseUrl: this.options.baseUrl,
-                    auth: this.options.auth,
-                }),
-            });
+            var cache = new Cache__default();
+            return cache.add(name, makeApiRequest, __assign({ params: params }, utils.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}
@@ -737,62 +880,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) {
@@ -805,112 +949,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__default((resolve, reject, onCancel) => {
-            if (this.user) {
+        return new CancelablePromise__default(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__default.CancelError) ;
             else {
                 // @ts-ignore
                 {
                     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') {
@@ -922,12 +1064,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