@nextgis/ngw-connector 1.16.8 → 1.17.0

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

@@ -1,94 +1,4 @@
-/** Bundle of @nextgis/ngw-connector; version: 1.16.8; author: NextGIS */
-/******************************************************************************
-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));
-}
-
+/** Bundle of @nextgis/ngw-connector; version: 1.17.0; author: NextGIS */
 var events = {exports: {}};
 
 var R = typeof Reflect === 'object' ? Reflect : null;
@@ -565,1686 +475,1605 @@ function eventTargetAgnosticAddListener(emitter, name, listener, flags) {
   }
 }
 
-var CancelError = /** @class */ (function (_super) {
-    __extends(CancelError, _super);
-    function CancelError() {
-        var _this = _super.call(this) || this;
-        _this.name = 'CancelError';
-        Object.setPrototypeOf(_this, CancelError.prototype);
-        return _this;
-    }
-    return CancelError;
-}(Error));
-
-var PromiseControl = /** @class */ (function () {
-    function PromiseControl(options) {
-        if (options === void 0) { options = {}; }
-        this.options = options;
-        this._promises = new Map();
-    }
-    Object.defineProperty(PromiseControl.prototype, "isLoaded", {
-        get: function () {
-            return this._promises.size > 0;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    PromiseControl.prototype.remove = function (promise) {
-        if (this._promises.has(promise)) {
-            this._promises.delete(promise);
-            this._onStop();
-        }
-    };
-    PromiseControl.prototype.get = function (promise) {
-        return this._promises.get(promise);
-    };
-    PromiseControl.prototype.add = function (promise, name) {
-        var _this = this;
-        var key = name ? name : promise;
-        var exist = this._promises.get(key);
-        if (this.options.onStart && !this.isLoaded) {
-            this.options.onStart();
-        }
-        if (exist) {
-            return exist;
-        }
-        this._promises.set(key, promise);
-        promise.finally(function () {
-            _this.remove(key);
-        });
-        return promise;
-    };
-    PromiseControl.prototype.abort = function () {
-        if (this.isLoaded) {
-            this._promises.forEach(function (x) {
-                if (x.cancel) {
-                    x.cancel();
-                }
-            });
-            this._promises.clear();
-            this._onStop();
-        }
-    };
-    PromiseControl.prototype.waitFunc = function (func, name) {
-        if (name === void 0) { name = ''; }
-        name = name || func.name;
-        var exist = this.get(name);
-        if (exist) {
-            return exist;
-        }
-        return this.add(func(), name);
-    };
-    PromiseControl.prototype.WaitForMe = function (name) {
-        if (name === void 0) { name = ''; }
-        var get = this.get.bind(this);
-        var add = this.add.bind(this);
-        return function (target, key, descriptor) {
-            var originalMethod = descriptor.value;
-            name = name || key;
-            descriptor.value = function () {
-                var args = [];
-                for (var _i = 0; _i < arguments.length; _i++) {
-                    args[_i] = arguments[_i];
-                }
-                var exist = get(name);
-                if (exist) {
-                    return exist;
-                }
-                var result = add(originalMethod.apply(this, args), name);
-                return result;
-            };
-            return descriptor;
-        };
-    };
-    /** @deprecated use {@link PromiseControl.WaitForMe } instead */
-    PromiseControl.prototype.GetOrCreateDecorator = function (name) {
-        if (name === void 0) { name = ''; }
-        return this.WaitForMe(name);
-    };
-    PromiseControl.prototype._onStop = function () {
-        if (this.options.onStop && !this.isLoaded) {
-            this.options.onStop();
-        }
-    };
-    return PromiseControl;
-}());
-
-var TimeoutError = /** @class */ (function (_super) {
-    __extends(TimeoutError, _super);
-    function TimeoutError() {
-        var _this = _super.call(this) || this;
-        _this.name = 'TimeoutError';
-        Object.setPrototypeOf(_this, TimeoutError.prototype);
-        return _this;
-    }
-    return TimeoutError;
-}(Error));
-
-var handleCallback = function (resolve, reject, callback, r) {
-    try {
-        resolve(callback(r));
-    }
-    catch (e) {
-        reject(e);
-    }
-};
-var ID$1 = 0;
-/**
- * Promise that can be canceled
- *
- * @example
- * Catch `CancelError`
- * ```javascript
- * import CancelablePromise from "@nextgis/cancelable-promise";
- *
- * const promise = new CancelablePromise((resolve, reject) => {
- *  setTimeout(() => resolve(), 100);
- * }).catch((er) => {
- *  if (er.name === "CancelError") {
- *    // handle cancel error
- *  }
- *  throw er;
- * });
- *
- * promise.cancel();
- * ```
- * @example
- * Handle `onCancel` callback
- * ```javascript
- * import CancelablePromise from "@nextgis/cancelable-promise";
- *
- * const promise = new CancelablePromise((resolve, reject, onCancel) => {
- *   const xhr = new XMLHttpRequest();
- *   xhr.open("GET", url, true);
- *   xhr.onload = () => {
- *     resolve(xhr.responseText);
- *   };
- *   xhr.onerror = (er) => {
- *     reject(er);
- *   };
- *
- *   onCancel(() => {
- *     xhr.abort();
- *   });
- *
- *   xhr.send();
- * });
- *
- * promise.cancel();
- * ```
- */
-var CancelablePromise$1 = /** @class */ (function () {
-    function CancelablePromise(executor, timeout) {
-        var _this = this;
-        this.id = ID$1++;
-        this._isCanceled = false;
-        this._isPending = true;
-        this._cancelHandlers = [];
-        this._children = [];
-        this._cancelPromise = new Promise(function (resolve_, reject_) {
-            _this._setCanceledCallback = function (er) { return resolve_(er || new CancelError()); };
-        });
-        var promises = [
-            this._cancelPromise,
-            new Promise(function (resolve, reject) {
-                var onResolve = function (value) {
-                    if (value instanceof CancelablePromise) {
-                        _this.attach(value);
-                    }
-                    else {
-                        _this._isPending = false;
-                    }
-                    // TODO: fix types, `undefined` not allowed since 19.12.2020
-                    resolve(value);
-                };
-                var onReject = function (error) {
-                    _this._isPending = false;
-                    reject(error);
-                };
-                var onCancel = function (handler) {
-                    if (!_this._isPending) {
-                        throw new Error('The `onCancel` handler was attached after the promise settled.');
-                    }
-                    _this._cancelHandlers.push(handler);
-                };
-                return executor(onResolve, onReject, onCancel);
-            }),
-        ];
-        if (timeout) {
-            promises.push(new Promise(function (resolve, reject) {
-                setTimeout(function () {
-                    if (_this._isPending) {
-                        try {
-                            _this.cancel();
-                        }
-                        finally {
-                            reject(new TimeoutError());
-                        }
-                    }
-                }, timeout);
-            }));
-        }
-        this._promise = Promise.race(promises);
-    }
-    CancelablePromise.createControl = function (opt) {
-        return new PromiseControl(opt);
-    };
-    CancelablePromise.resolve = function (value) {
-        return new CancelablePromise(function (resolve) { return resolve(value); });
-    };
-    CancelablePromise.reject = function (value) {
-        return new CancelablePromise(function (resolve, reject) { return reject(value); });
-    };
-    CancelablePromise.all = function (values) {
-        var _this = this;
-        return new CancelablePromise(function (resolve, reject) {
-            Promise.all(values).then(resolve).catch(reject);
-        }).catch(function (er) {
-            if (er instanceof _this.CancelError) {
-                for (var _i = 0, values_1 = values; _i < values_1.length; _i++) {
-                    var v = values_1[_i];
-                    var v_ = v;
-                    if ('cancel' in v_) {
-                        v_.cancel();
-                    }
-                }
-            }
-            throw er;
-        });
-    };
-    CancelablePromise.prototype.attach = function (p) {
-        if (this._isCanceled) {
-            p.cancel();
-        }
-        else {
-            this._children.push(p);
-        }
-    };
-    CancelablePromise.prototype.then = function (onfulfilled, onrejected) {
-        var _this = this;
-        var p = new CancelablePromise(function (resolve, reject) {
-            if (_this._promise) {
-                var reject_1 = function (r) {
-                    if (onrejected) {
-                        handleCallback(resolve, reject, onrejected, r);
-                    }
-                    else {
-                        reject(r);
-                    }
-                };
-                _this._promise.then(function (r) {
-                    if (_this._isCanceled) {
-                        reject_1(r);
-                    }
-                    else {
-                        if (onfulfilled) {
-                            handleCallback(resolve, reject, onfulfilled, r);
-                        }
-                        else {
-                            resolve(r);
-                        }
-                    }
-                }, reject_1);
-            }
-        });
-        p._parentPromise = this;
-        this._children.push(p);
-        return p;
-    };
-    CancelablePromise.prototype.catch = function (onrejected) {
-        if (this._isCanceled && onrejected) {
-            onrejected(new CancelError());
-        }
-        return this.then(undefined, onrejected);
-    };
-    CancelablePromise.prototype.finally = function (onfinally) {
-        if (this._promise) {
-            return this._promise.finally(onfinally);
-        }
-        if (this._isCanceled) {
-            return Promise.reject(new CancelError());
-        }
-        return Promise.reject(onfinally);
-    };
-    CancelablePromise.prototype.cancel = function () {
-        // No reason to run cancel action if promise is already complete
-        if (this._isCanceled || !this._isPending) {
-            return this;
-        }
-        this._isCanceled = true;
-        var parent = this._getTopParent();
-        if (parent) {
-            parent.cancel();
-        }
-        if (this._children) {
-            this._children.forEach(function (x) { return x.cancel(); });
-        }
-        if (this._isPending) {
-            if (this._cancelHandlers.length) {
-                try {
-                    for (var _i = 0, _a = this._cancelHandlers; _i < _a.length; _i++) {
-                        var handler = _a[_i];
-                        handler();
-                    }
-                }
-                catch (error) {
-                    // this._setCanceledCallback(error);
-                }
-            }
-            if (this._setCanceledCallback) {
-                this._setCanceledCallback();
-            }
-        }
-        this._destroy();
-        return this;
-    };
-    CancelablePromise.prototype._getTopParent = function () {
-        var parent = this._parentPromise;
-        var hasParent = !!parent;
-        while (hasParent) {
-            if (parent && parent._parentPromise) {
-                parent = parent._parentPromise;
-                hasParent = !!parent;
-            }
-            else {
-                hasParent = false;
-            }
-        }
-        return parent;
-    };
-    CancelablePromise.prototype._destroy = function () {
-        this._setCanceledCallback = undefined;
-        this._cancelPromise = undefined;
-        this._promise = undefined;
-    };
-    CancelablePromise.CancelError = CancelError;
-    CancelablePromise.TimeoutError = TimeoutError;
-    CancelablePromise.PromiseControl = PromiseControl;
-    return CancelablePromise;
-}());
+class CancelError extends Error {
+    constructor() {
+        super();
+        this.name = 'CancelError';
+        Object.setPrototypeOf(this, CancelError.prototype);
+    }
+}
+
+class PromiseControl {
+    constructor(options = {}) {
+        this.options = options;
+        this._promises = new Map();
+    }
+    get isLoaded() {
+        return this._promises.size > 0;
+    }
+    remove(promise) {
+        if (this._promises.has(promise)) {
+            this._promises.delete(promise);
+            this._onStop();
+        }
+    }
+    get(promise) {
+        return this._promises.get(promise);
+    }
+    add(promise, name) {
+        const key = name ? name : promise;
+        const exist = this._promises.get(key);
+        if (this.options.onStart && !this.isLoaded) {
+            this.options.onStart();
+        }
+        if (exist) {
+            return exist;
+        }
+        this._promises.set(key, promise);
+        promise.finally(() => {
+            this.remove(key);
+        });
+        return promise;
+    }
+    abort() {
+        if (this.isLoaded) {
+            this._promises.forEach((x) => {
+                if (x.cancel) {
+                    x.cancel();
+                }
+            });
+            this._promises.clear();
+            this._onStop();
+        }
+    }
+    waitFunc(func, name = '') {
+        name = name || func.name;
+        const exist = this.get(name);
+        if (exist) {
+            return exist;
+        }
+        return this.add(func(), name);
+    }
+    WaitForMe(name = '') {
+        const get = this.get.bind(this);
+        const add = this.add.bind(this);
+        return function (target, key, descriptor) {
+            const originalMethod = descriptor.value;
+            name = name || key;
+            descriptor.value = function (...args) {
+                const exist = get(name);
+                if (exist) {
+                    return exist;
+                }
+                const result = add(originalMethod.apply(this, args), name);
+                return result;
+            };
+            return descriptor;
+        };
+    }
+    /** @deprecated use {@link PromiseControl.WaitForMe } instead */
+    GetOrCreateDecorator(name = '') {
+        return this.WaitForMe(name);
+    }
+    _onStop() {
+        if (this.options.onStop && !this.isLoaded) {
+            this.options.onStop();
+        }
+    }
+}
+
+class TimeoutError extends Error {
+    constructor() {
+        super();
+        this.name = 'TimeoutError';
+        Object.setPrototypeOf(this, TimeoutError.prototype);
+    }
+}
+
+const handleCallback = (resolve, reject, callback, r) => {
+    try {
+        resolve(callback(r));
+    }
+    catch (e) {
+        reject(e);
+    }
+};
+let ID$1 = 0;
+/**
+ * Promise that can be canceled
+ *
+ * @example
+ * Catch `CancelError`
+ * ```javascript
+ * import CancelablePromise from "@nextgis/cancelable-promise";
+ *
+ * const promise = new CancelablePromise((resolve, reject) => {
+ *  setTimeout(() => resolve(), 100);
+ * }).catch((er) => {
+ *  if (er.name === "CancelError") {
+ *    // handle cancel error
+ *  }
+ *  throw er;
+ * });
+ *
+ * promise.cancel();
+ * ```
+ * @example
+ * Handle `onCancel` callback
+ * ```javascript
+ * import CancelablePromise from "@nextgis/cancelable-promise";
+ *
+ * const promise = new CancelablePromise((resolve, reject, onCancel) => {
+ *   const xhr = new XMLHttpRequest();
+ *   xhr.open("GET", url, true);
+ *   xhr.onload = () => {
+ *     resolve(xhr.responseText);
+ *   };
+ *   xhr.onerror = (er) => {
+ *     reject(er);
+ *   };
+ *
+ *   onCancel(() => {
+ *     xhr.abort();
+ *   });
+ *
+ *   xhr.send();
+ * });
+ *
+ * promise.cancel();
+ * ```
+ */
+class CancelablePromise$1 {
+    constructor(executor, timeout) {
+        this.id = ID$1++;
+        this._isCanceled = false;
+        this._isPending = true;
+        this._cancelHandlers = [];
+        this._children = [];
+        this._cancelPromise = new Promise((resolve_, reject_) => {
+            this._setCanceledCallback = (er) => resolve_(er || new CancelError());
+        });
+        const promises = [
+            this._cancelPromise,
+            new Promise((resolve, reject) => {
+                const onResolve = (value) => {
+                    if (value instanceof CancelablePromise$1) {
+                        this.attach(value);
+                    }
+                    else {
+                        this._isPending = false;
+                    }
+                    // TODO: fix types, `undefined` not allowed since 19.12.2020
+                    resolve(value);
+                };
+                const onReject = (error) => {
+                    this._isPending = false;
+                    reject(error);
+                };
+                const onCancel = (handler) => {
+                    if (!this._isPending) {
+                        throw new Error('The `onCancel` handler was attached after the promise settled.');
+                    }
+                    this._cancelHandlers.push(handler);
+                };
+                return executor(onResolve, onReject, onCancel);
+            }),
+        ];
+        if (timeout) {
+            promises.push(new Promise((resolve, reject) => {
+                setTimeout(() => {
+                    if (this._isPending) {
+                        try {
+                            this.cancel();
+                        }
+                        finally {
+                            reject(new TimeoutError());
+                        }
+                    }
+                }, timeout);
+            }));
+        }
+        this._promise = Promise.race(promises);
+    }
+    static createControl(opt) {
+        return new PromiseControl(opt);
+    }
+    static resolve(value) {
+        return new CancelablePromise$1((resolve) => resolve(value));
+    }
+    static reject(value) {
+        return new CancelablePromise$1((resolve, reject) => reject(value));
+    }
+    static all(values) {
+        return new CancelablePromise$1((resolve, reject) => {
+            Promise.all(values).then(resolve).catch(reject);
+        }).catch((er) => {
+            if (er instanceof this.CancelError) {
+                for (const v of values) {
+                    const v_ = v;
+                    if ('cancel' in v_) {
+                        v_.cancel();
+                    }
+                }
+            }
+            throw er;
+        });
+    }
+    attach(p) {
+        if (this._isCanceled) {
+            p.cancel();
+        }
+        else {
+            this._children.push(p);
+        }
+    }
+    then(onfulfilled, onrejected) {
+        const p = new CancelablePromise$1((resolve, reject) => {
+            if (this._promise) {
+                const reject_ = (r) => {
+                    if (onrejected) {
+                        handleCallback(resolve, reject, onrejected, r);
+                    }
+                    else {
+                        reject(r);
+                    }
+                };
+                this._promise.then((r) => {
+                    if (this._isCanceled) {
+                        reject_(r);
+                    }
+                    else {
+                        if (onfulfilled) {
+                            handleCallback(resolve, reject, onfulfilled, r);
+                        }
+                        else {
+                            resolve(r);
+                        }
+                    }
+                }, reject_);
+            }
+        });
+        p._parentPromise = this;
+        this._children.push(p);
+        return p;
+    }
+    catch(onrejected) {
+        if (this._isCanceled && onrejected) {
+            onrejected(new CancelError());
+        }
+        return this.then(undefined, onrejected);
+    }
+    finally(onfinally) {
+        if (this._promise) {
+            return this._promise.finally(onfinally);
+        }
+        if (this._isCanceled) {
+            return Promise.reject(new CancelError());
+        }
+        return Promise.reject(onfinally);
+    }
+    cancel() {
+        // No reason to run cancel action if promise is already complete
+        if (this._isCanceled || !this._isPending) {
+            return this;
+        }
+        this._isCanceled = true;
+        const parent = this._getTopParent();
+        if (parent) {
+            parent.cancel();
+        }
+        if (this._children) {
+            this._children.forEach((x) => x.cancel());
+        }
+        if (this._isPending) {
+            if (this._cancelHandlers.length) {
+                try {
+                    for (const handler of this._cancelHandlers) {
+                        handler();
+                    }
+                }
+                catch (error) {
+                    // this._setCanceledCallback(error);
+                }
+            }
+            if (this._setCanceledCallback) {
+                this._setCanceledCallback();
+            }
+        }
+        this._destroy();
+        return this;
+    }
+    _getTopParent() {
+        let parent = this._parentPromise;
+        let hasParent = !!parent;
+        while (hasParent) {
+            if (parent && parent._parentPromise) {
+                parent = parent._parentPromise;
+                hasParent = !!parent;
+            }
+            else {
+                hasParent = false;
+            }
+        }
+        return parent;
+    }
+    _destroy() {
+        this._setCanceledCallback = undefined;
+        this._cancelPromise = undefined;
+        this._promise = undefined;
+    }
+}
+CancelablePromise$1.CancelError = CancelError;
+CancelablePromise$1.TimeoutError = TimeoutError;
+CancelablePromise$1.PromiseControl = PromiseControl;
 Object.setPrototypeOf(CancelablePromise$1.prototype, Promise.prototype);
 
-/**
- * A promise you can stop
- *
- * @packageDocumentation
- * @module cancelable-promise
- */
+/**
+ * A promise you can stop
+ *
+ * @packageDocumentation
+ * @module cancelable-promise
+ */
 var CancelablePromise = CancelablePromise$1;
 
-/**
- * from https://github.com/CesiumGS/cesium/blob/master/Source/Core/defined.js
- *
- * @param val - The object.
- * @returns Returns true if the object is defined, returns false otherwise.
- *
- * @example
- * ```javascript
- * if (defined(positions)) {
- *   doSomething();
- * } else {
- *   doSomethingElse();
- * }
- * ```
- */
-function defined(val) {
-    return val !== undefined && val !== null;
-}
-/**
- * from https://github.com/CesiumGS/cesium/blob/master/Source/Core/defined.js
- *
- * @param val - The object.
- * @returns Returns true if the object is defined and not empty string, returns false otherwise.
- *
- * @example
- * ```javascript
- * full('foo') // true
- * full('') // false
- * full(undefined) // false
- * full(0) // true
- * ```
- */
-function full(val) {
-    return typeof val === 'string' ? !!val : defined(val);
+/**
+ * from https://github.com/CesiumGS/cesium/blob/master/Source/Core/defined.js
+ *
+ * @param val - The object.
+ * @returns Returns true if the object is defined, returns false otherwise.
+ *
+ * @example
+ * ```javascript
+ * if (defined(positions)) {
+ *   doSomething();
+ * } else {
+ *   doSomethingElse();
+ * }
+ * ```
+ */
+function defined(val) {
+    return val !== undefined && val !== null;
+}
+/**
+ * from https://github.com/CesiumGS/cesium/blob/master/Source/Core/defined.js
+ *
+ * @param val - The object.
+ * @returns Returns true if the object is defined and not empty string, returns false otherwise.
+ *
+ * @example
+ * ```javascript
+ * full('foo') // true
+ * full('') // false
+ * full(undefined) // false
+ * full(0) // true
+ * ```
+ */
+function full(val) {
+    return typeof val === 'string' ? !!val : defined(val);
 }
 
-function isEqual(a, b, o, p) {
-    if (a instanceof Array) {
-        if (!(b instanceof Array))
-            return false;
-        //if (compareObjects(oVal, pVal === false) return false
-        //would work, too, and perhaps is a better fit, still, this is easy, too
-        return b.sort().join('') === a.sort().join('');
-    }
-    else if (a instanceof Date) {
-        if (!(b instanceof Date))
-            return false;
-        return '' + a === '' + b;
-    }
-    else if (a instanceof Function) {
-        if (!(b instanceof Function))
-            return false;
-        //ignore functions, or check them regardless?
-    }
-    else if (a instanceof Object) {
-        if (!(b instanceof Object))
-            return false;
-        if (a === o) {
-            return b === p;
-        }
-        else {
-            return objectDeepEqual(a, b);
-        }
-    }
-    return a === b;
-}
-// based on https://stackoverflow.com/a/13143059
-function objectDeepEqual(o, p) {
-    var keysO = Object.keys(o).sort();
-    var keysP = Object.keys(p).sort();
-    if (keysO.length !== keysP.length)
-        return false;
-    if (keysO.join('') !== keysP.join(''))
-        return false;
-    for (var i = 0; i < keysO.length; i++) {
-        var oVal = o[keysO[i]];
-        var pVal = p[keysP[i]];
-        if (!isEqual(oVal, pVal, o, p)) {
-            return false;
-        }
-    }
-    return true;
+function isEqual(a, b, o, p) {
+    if (a instanceof Array) {
+        if (!(b instanceof Array))
+            return false;
+        //if (compareObjects(oVal, pVal === false) return false
+        //would work, too, and perhaps is a better fit, still, this is easy, too
+        return b.sort().join('') === a.sort().join('');
+    }
+    else if (a instanceof Date) {
+        if (!(b instanceof Date))
+            return false;
+        return '' + a === '' + b;
+    }
+    else if (a instanceof Function) {
+        if (!(b instanceof Function))
+            return false;
+        //ignore functions, or check them regardless?
+    }
+    else if (a instanceof Object) {
+        if (!(b instanceof Object))
+            return false;
+        if (a === o) {
+            return b === p;
+        }
+        else {
+            return objectDeepEqual(a, b);
+        }
+    }
+    return a === b;
+}
+// based on https://stackoverflow.com/a/13143059
+function objectDeepEqual(o, p) {
+    const keysO = Object.keys(o).sort();
+    const keysP = Object.keys(p).sort();
+    if (keysO.length !== keysP.length)
+        return false;
+    if (keysO.join('') !== keysP.join(''))
+        return false;
+    for (let i = 0; i < keysO.length; i++) {
+        const oVal = o[keysO[i]];
+        const pVal = p[keysP[i]];
+        if (!isEqual(oVal, pVal, o, p)) {
+            return false;
+        }
+    }
+    return true;
 }
 
-function objectRemoveEmpty(obj) {
-    var newObj = {};
-    Object.keys(obj).forEach(function (key) {
-        if (!(obj[key] instanceof Array) && obj[key] === Object(obj[key])) {
-            newObj[key] = objectRemoveEmpty(obj[key]);
-        }
-        else if (obj[key] !== undefined) {
-            newObj[key] = obj[key];
-        }
-    });
-    return newObj;
+function objectRemoveEmpty(obj) {
+    const newObj = {};
+    Object.keys(obj).forEach((key) => {
+        if (!(obj[key] instanceof Array) && obj[key] === Object(obj[key])) {
+            newObj[key] = objectRemoveEmpty(obj[key]);
+        }
+        else if (obj[key] !== undefined) {
+            newObj[key] = obj[key];
+        }
+    });
+    return newObj;
 }
 
-function fixUrlStr(url) {
-    // remove double slash
-    return url.replace(/([^:]\/)\/+/g, '$1');
+function fixUrlStr(url) {
+    // remove double slash
+    return url.replace(/([^:]\/)\/+/g, '$1');
 }
 
-/**
- * @example
- * ```javascript
- * const cache1 = new Cache();
- * cache1.add('foo', 'value');
- *
- * const cache2 = new Cache();
- * cache2.match('foo'); // value
- *
- * const cache3 = new Cache({ namespace: 'foo' });
- * cache3.match('foo'); // undefined
- * ```
- *
- * @example
- * ```javascript
- * let COUNTER = 0;
- * const createPromise = () => new Promise((res) => {
- *   COUNTER++
- *   setTimeout(() => res('Ok'), 300)
- * });
- *
- * const cache = new Cache();
- * for (let i = 0; i < 10; i++) {
- *   cache.add('foo', createPromise).then((data) => {
- *     console.log(data); // 'Ok'
- *   });
- * }
- * console.log(COUNTER); // 1
- * ```
- */
-var Cache$1 = /** @class */ (function () {
-    function Cache(options) {
-        if (options === void 0) { options = {}; }
-        var _a;
-        this.cache = [];
-        var namespace = (_a = options.namespace) !== null && _a !== void 0 ? _a : 'default';
-        if (Cache.instance[namespace]) {
-            return Cache.instance[namespace];
-        }
-        Cache.instance[namespace] = this;
-        return this;
-    }
-    Cache.prototype.clean = function () {
-        this.cache.length = 0;
-    };
-    Cache.prototype.all = function () {
-        return this.cache;
-    };
-    /**
-     * Caching only a non-empty value.
-     *
-     * Useful for get or create strategy
-     * @example
-     * ```javascript
-     * const cache = new Cache();
-     * const getItemFunc = () => fetch(url).then((data) => {
-     *  return data.json(); // undefined
-     * });
-     * const item = await cache.addFull('foo', getItemFunc);
-     * if (!item) {
-     *   await createItem(); // 'New item'
-     * }
-     *
-     * // somewhere else in the code
-     * const item = await cache.addFull('foo', getItemFunc).then((resp) => {
-     *   console.log(resp); // 'New item'
-     * })
-     *
-     * ```
-     */
-    Cache.prototype.addFull = function (key, valueToSet, props) {
-        return this.add(key, valueToSet, props, true);
-    };
-    Cache.prototype.add = function (key, valueToSet, props, onlyFull) {
-        var _this = this;
-        var exist = this._find(key, props);
-        if (!exist) {
-            var value = void 0;
-            if (valueToSet instanceof Function) {
-                value = valueToSet();
-            }
-            else {
-                value = valueToSet;
-            }
-            var props_ = props && JSON.parse(JSON.stringify(objectRemoveEmpty(props)));
-            var cacheItem = {
-                key: key,
-                value: value,
-                props: props_,
-                // TODO: remove backward compatibility use only props
-                options: props_,
-            };
-            if (onlyFull && !full(value)) {
-                return value;
-            }
-            this.cache.push(cacheItem);
-            if (value instanceof Promise) {
-                value.catch(function (er) {
-                    _this.delete(key, props);
-                    throw er;
-                });
-                if (onlyFull) {
-                    value.then(function (x) {
-                        if (!full(x)) {
-                            _this.delete(key, props);
-                        }
-                        return x;
-                    });
-                }
-                return value;
-            }
-            return value;
-        }
-        else {
-            return exist.value;
-        }
-    };
-    Cache.prototype.match = function (key, props) {
-        var cacheRecord = this._find(key, props);
-        if (cacheRecord) {
-            return cacheRecord.value;
-        }
-    };
-    Cache.prototype.matchAll = function (key, props) {
-        var _this = this;
-        if (key) {
-            return this.cache
-                .filter(function (x) { return _this._filter(x, key, props); })
-                .map(function (x) { return x.value; });
-        }
-        return this.cache.map(function (x) { return x.value; });
-    };
-    Cache.prototype.delete = function (keyOrItem, props) {
-        var _this = this;
-        var exist = [];
-        if (typeof keyOrItem === 'string') {
-            exist = this.cache.filter(function (x) { return _this._filter(x, keyOrItem, props); });
-        }
-        else {
-            exist.push(keyOrItem);
-        }
-        for (var _i = 0, exist_1 = exist; _i < exist_1.length; _i++) {
-            var e = exist_1[_i];
-            var index = this.cache.indexOf(e);
-            this.cache.splice(index, 1);
-        }
-    };
-    Cache.prototype._find = function (key, props) {
-        var _this = this;
-        return this.cache.find(function (x) { return _this._filter(x, key, props); });
-    };
-    Cache.prototype._filter = function (item, key, props) {
-        if (item.key === key) {
-            if (props) {
-                // TODO: remove backward compatibility
-                var itemProps = item.props || item.options;
-                return objectDeepEqual(itemProps || {}, objectRemoveEmpty(props));
-            }
-            return true;
-        }
-        return false;
-    };
-    Cache.instance = {};
-    return Cache;
-}());
-
-/**
- * Caching for asynchronous functions
- *
- * @packageDocumentation
- * @module cache
- */
+/**
+ * @example
+ * ```javascript
+ * const cache1 = new Cache();
+ * cache1.add('foo', 'value');
+ *
+ * const cache2 = new Cache();
+ * cache2.match('foo'); // value
+ *
+ * const cache3 = new Cache({ namespace: 'foo' });
+ * cache3.match('foo'); // undefined
+ * ```
+ *
+ * @example
+ * ```javascript
+ * let COUNTER = 0;
+ * const createPromise = () => new Promise((res) => {
+ *   COUNTER++
+ *   setTimeout(() => res('Ok'), 300)
+ * });
+ *
+ * const cache = new Cache();
+ * for (let i = 0; i < 10; i++) {
+ *   cache.add('foo', createPromise).then((data) => {
+ *     console.log(data); // 'Ok'
+ *   });
+ * }
+ * console.log(COUNTER); // 1
+ * ```
+ */
+class Cache$1 {
+    constructor(options = {}) {
+        var _a;
+        this.cache = [];
+        const namespace = (_a = options.namespace) !== null && _a !== void 0 ? _a : 'default';
+        if (Cache$1.instance[namespace]) {
+            return Cache$1.instance[namespace];
+        }
+        Cache$1.instance[namespace] = this;
+        return this;
+    }
+    clean() {
+        this.cache.length = 0;
+    }
+    all() {
+        return this.cache;
+    }
+    /**
+     * Caching only a non-empty value.
+     *
+     * Useful for get or create strategy
+     * @example
+     * ```javascript
+     * const cache = new Cache();
+     * const getItemFunc = () => fetch(url).then((data) => {
+     *  return data.json(); // undefined
+     * });
+     * const item = await cache.addFull('foo', getItemFunc);
+     * if (!item) {
+     *   await createItem(); // 'New item'
+     * }
+     *
+     * // somewhere else in the code
+     * const item = await cache.addFull('foo', getItemFunc).then((resp) => {
+     *   console.log(resp); // 'New item'
+     * })
+     *
+     * ```
+     */
+    addFull(key, valueToSet, props) {
+        return this.add(key, valueToSet, props, true);
+    }
+    add(key, valueToSet, props, onlyFull) {
+        const exist = this._find(key, props);
+        if (!exist) {
+            let value;
+            if (valueToSet instanceof Function) {
+                value = valueToSet();
+            }
+            else {
+                value = valueToSet;
+            }
+            const props_ = props && JSON.parse(JSON.stringify(objectRemoveEmpty(props)));
+            const cacheItem = {
+                key,
+                value,
+                props: props_,
+                // TODO: remove backward compatibility use only props
+                options: props_,
+            };
+            if (onlyFull && !full(value)) {
+                return value;
+            }
+            this.cache.push(cacheItem);
+            if (value instanceof Promise) {
+                value.catch((er) => {
+                    this.delete(key, props);
+                    throw er;
+                });
+                if (onlyFull) {
+                    value.then((x) => {
+                        if (!full(x)) {
+                            this.delete(key, props);
+                        }
+                        return x;
+                    });
+                }
+                return value;
+            }
+            return value;
+        }
+        else {
+            return exist.value;
+        }
+    }
+    match(key, props) {
+        const cacheRecord = this._find(key, props);
+        if (cacheRecord) {
+            return cacheRecord.value;
+        }
+    }
+    matchAll(key, props) {
+        if (key) {
+            return this.cache
+                .filter((x) => this._filter(x, key, props))
+                .map((x) => x.value);
+        }
+        return this.cache.map((x) => x.value);
+    }
+    delete(keyOrItem, props) {
+        let exist = [];
+        if (typeof keyOrItem === 'string') {
+            exist = this.cache.filter((x) => this._filter(x, keyOrItem, props));
+        }
+        else {
+            exist.push(keyOrItem);
+        }
+        for (const e of exist) {
+            const index = this.cache.indexOf(e);
+            this.cache.splice(index, 1);
+        }
+    }
+    _find(key, props) {
+        return this.cache.find((x) => this._filter(x, key, props));
+    }
+    _filter(item, key, props) {
+        if (item.key === key) {
+            if (props) {
+                // TODO: remove backward compatibility
+                const itemProps = item.props || item.options;
+                return objectDeepEqual(itemProps || {}, objectRemoveEmpty(props));
+            }
+            return true;
+        }
+        return false;
+    }
+}
+Cache$1.instance = {};
+
+/**
+ * Caching for asynchronous functions
+ *
+ * @packageDocumentation
+ * @module cache
+ */
 var Cache = Cache$1;
 
-/**
- * Thrown when...
- */
-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));
-
-/**
- * Thrown when...
- */
-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]';
+/**
+ * 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
+    }
+}
+
+/**
+ * Thrown when...
+ */
+class NgwError extends Error {
+    constructor(er) {
+        super();
+        this.name = 'NgwError';
+        Object.assign(this, er);
+        Object.setPrototypeOf(this, NgwError.prototype);
+    }
+}
+
+function isObject(val) {
+    return Object.prototype.toString.call(val) === '[object Object]';
+}
+
+let loadData;
+// @ts-ignore
+{
+    loadData = (url, callback, options = {}, error, onCancel) => {
+        options.method = options.method || 'GET';
+        const xhr = new XMLHttpRequest();
+        xhr.open(options.method || 'GET', url, true); // true for asynchronous
+        if (options.responseType === 'blob') {
+            xhr.responseType = options.responseType;
+        }
+        const getResponseText = () => {
+            try {
+                return JSON.parse(xhr.responseText);
+            }
+            catch (er) {
+                return xhr.responseText;
+            }
+        };
+        const processingResponse = (forError = false) => {
+            const cb = forError ? error : callback;
+            if (options.responseType === 'blob') {
+                cb(xhr.response);
+            }
+            else {
+                if (xhr.responseText) {
+                    cb(getResponseText());
+                }
+                else {
+                    error({ message: '' });
+                }
+            }
+        };
+        xhr.onload = () => {
+            if ([401, 403, 404, 422, 500].indexOf(xhr.status) !== -1) {
+                error(new NgwError(getResponseText()));
+            }
+            processingResponse();
+        };
+        // xhr.onreadystatechange = () => {
+        //   if (
+        //     (xhr.readyState === 4 && xhr.status === 200) ||
+        //     (xhr.readyState === 3 && xhr.status === 201)
+        //   ) {
+        //     processingResponse();
+        //   } else if (xhr.readyState === 3 && xhr.status === 400) {
+        //     processingResponse();
+        //   } else if (xhr.readyState === 4 && xhr.status === 500) {
+        //     processingResponse();
+        //   } else if (xhr.readyState === 4 && xhr.status === 401) {
+        //     error(xhr.statusText);
+        //   } else if (xhr.readyState === 4) {
+        //     error('request error');
+        //   }
+        // };
+        xhr.onerror = (er) => {
+            if (xhr.status === 0) {
+                error(new NetworkError(url));
+            }
+            else {
+                error(er);
+            }
+        };
+        xhr.upload.onprogress = function (e) {
+            if (e.lengthComputable) {
+                const percentComplete = (e.loaded / e.total) * 100;
+                if (options.onProgress) {
+                    options.onProgress(percentComplete, e);
+                }
+                // console.log(percentComplete + '% uploaded');
+            }
+        };
+        const headers = options.headers;
+        if (headers) {
+            for (const h in headers) {
+                const header = headers[h];
+                if (typeof header === 'string') {
+                    xhr.setRequestHeader(h, header);
+                }
+            }
+        }
+        if (options.withCredentials !== undefined) {
+            xhr.withCredentials = options.withCredentials;
+        }
+        let data;
+        if (options.file) {
+            data = new FormData();
+            data.append('file', options.file);
+            if (options.data) {
+                for (const d in options.data) {
+                    data.append(d, data[d]);
+                }
+            }
+        }
+        else {
+            data = options.data
+                ? typeof options.data === 'string'
+                    ? options.data
+                    : JSON.stringify(options.data)
+                : null;
+        }
+        if (onCancel) {
+            onCancel(() => {
+                xhr.abort();
+            });
+        }
+        xhr.send(data);
+    };
 }
 
-var loadData;
-// @ts-ignore
-{
-    loadData = function (url, callback, options, error, onCancel) {
-        if (options === void 0) { options = {}; }
-        options.method = options.method || 'GET';
-        var xhr = new XMLHttpRequest();
-        xhr.open(options.method || 'GET', url, true); // true for asynchronous
-        if (options.responseType === 'blob') {
-            xhr.responseType = options.responseType;
-        }
-        var getResponseText = function () {
-            try {
-                return JSON.parse(xhr.responseText);
-            }
-            catch (er) {
-                return xhr.responseText;
-            }
-        };
-        var processingResponse = function (forError) {
-            if (forError === void 0) { forError = false; }
-            var cb = forError ? error : callback;
-            if (options.responseType === 'blob') {
-                cb(xhr.response);
-            }
-            else {
-                if (xhr.responseText) {
-                    cb(getResponseText());
-                }
-                else {
-                    error({ message: '' });
-                }
-            }
-        };
-        xhr.onload = function () {
-            if ([401, 403, 404, 422, 500].indexOf(xhr.status) !== -1) {
-                error(new NgwError(getResponseText()));
-            }
-            processingResponse();
-        };
-        // xhr.onreadystatechange = () => {
-        //   if (
-        //     (xhr.readyState === 4 && xhr.status === 200) ||
-        //     (xhr.readyState === 3 && xhr.status === 201)
-        //   ) {
-        //     processingResponse();
-        //   } else if (xhr.readyState === 3 && xhr.status === 400) {
-        //     processingResponse();
-        //   } else if (xhr.readyState === 4 && xhr.status === 500) {
-        //     processingResponse();
-        //   } else if (xhr.readyState === 4 && xhr.status === 401) {
-        //     error(xhr.statusText);
-        //   } else if (xhr.readyState === 4) {
-        //     error('request error');
-        //   }
-        // };
-        xhr.onerror = function (er) {
-            if (xhr.status === 0) {
-                error(new NetworkError(url));
-            }
-            else {
-                error(er);
-            }
-        };
-        xhr.upload.onprogress = function (e) {
-            if (e.lengthComputable) {
-                var percentComplete = (e.loaded / e.total) * 100;
-                if (options.onProgress) {
-                    options.onProgress(percentComplete, e);
-                }
-                // console.log(percentComplete + '% uploaded');
-            }
-        };
-        var headers = options.headers;
-        if (headers) {
-            for (var h in headers) {
-                var header = headers[h];
-                if (typeof header === 'string') {
-                    xhr.setRequestHeader(h, header);
-                }
-            }
-        }
-        if (options.withCredentials !== undefined) {
-            xhr.withCredentials = options.withCredentials;
-        }
-        var data;
-        if (options.file) {
-            data = new FormData();
-            data.append('file', options.file);
-            if (options.data) {
-                for (var d in options.data) {
-                    data.append(d, data[d]);
-                }
-            }
-        }
-        else {
-            data = options.data
-                ? typeof options.data === 'string'
-                    ? options.data
-                    : JSON.stringify(options.data)
-                : null;
-        }
-        if (onCancel) {
-            onCancel(function () {
-                xhr.abort();
-            });
-        }
-        xhr.send(data);
-    };
+// https://github.com/Leaflet/Leaflet/blob/b507e21c510b53cd704fb8d3f89bb46ea925c8eb/src/core/Util.js#L165
+const templateRe = /\{ *([\w_-]+) *\}/g;
+function template(str, data) {
+    return str.replace(templateRe, (s, key) => {
+        let value = data[key];
+        if (value === undefined) {
+            throw new Error('No value provided for letiable ' + s);
+        }
+        else if (typeof value === 'function') {
+            value = value(data);
+        }
+        return value;
+    });
 }
 
-// https://github.com/Leaflet/Leaflet/blob/b507e21c510b53cd704fb8d3f89bb46ea925c8eb/src/core/Util.js#L165
-var templateRe = /\{ *([\w_-]+) *\}/g;
-function template(str, data) {
-    return str.replace(templateRe, function (s, key) {
-        var value = data[key];
-        if (value === undefined) {
-            throw new Error('No value provided for letiable ' + s);
-        }
-        else if (typeof value === 'function') {
-            value = value(data);
-        }
-        return value;
-    });
+function apiRequest(opt) {
+    const params = opt.params;
+    return new CancelablePromise((resolve, reject) => {
+        opt.connector
+            .connect()
+            .then((apiItems) => {
+            let apiItem = apiItems && apiItems[opt.name];
+            if (apiItem) {
+                apiItem = [...apiItem];
+                let url = apiItem.shift();
+                if (apiItem.length) {
+                    const replaceParams = {};
+                    for (let fry = 0; fry < apiItem.length; fry++) {
+                        const arg = apiItem[fry];
+                        replaceParams[fry] = '{' + arg + '}';
+                        if (params[arg] === undefined) {
+                            throw new Error('`' + arg + '`' + ' url api argument is not specified');
+                        }
+                    }
+                    if (url) {
+                        url = template(url, replaceParams);
+                    }
+                }
+                // Transfer part of the parameters from `params` to the URL string
+                if (params) {
+                    const paramArray = [];
+                    const paramList = params.paramList;
+                    if (Array.isArray(paramList)) {
+                        delete params.paramList;
+                        paramList.forEach((x) => {
+                            paramArray.push(`${x[0]}=${x[1]}`);
+                        });
+                    }
+                    for (const p in params) {
+                        if (apiItem.indexOf(p) === -1) {
+                            paramArray.push(`${p}=${params[p]}`);
+                        }
+                    }
+                    if (paramArray.length) {
+                        url = url + '?' + paramArray.join('&');
+                    }
+                }
+                if (url) {
+                    resolve(opt.connector.makeQuery(url, params, opt.requestOptions));
+                }
+                else {
+                    reject(new Error('request url is not set'));
+                }
+            }
+            else {
+                resolve(undefined);
+            }
+        })
+            .catch((er) => {
+            reject(er);
+        });
+    });
+}
+
+/**
+ * Thrown when ...
+ */
+class ResourceNotFoundError extends NgwError {
+    constructor(obj) {
+        super(obj);
+        this.name = 'ResourceNotFoundError';
+        this.exception = 'nextgisweb.resource.exception.ResourceNotFound';
+        Object.setPrototypeOf(this, ResourceNotFoundError.prototype);
+    }
+}
+
+/**
+ * Thrown when ...
+ */
+class InsufficientPermissionsError extends NgwError {
+    constructor(obj) {
+        super(obj);
+        this.name = 'InsufficientPermissionsError';
+        this.exception = 'nextgisweb.core.exception.InsufficientPermissions';
+        Object.setPrototypeOf(this, InsufficientPermissionsError.prototype);
+    }
+}
+
+const CONNECTORS = [];
+function addConnector(connector) {
+    CONNECTORS.push(connector);
+}
+function findConnector(options) {
+    return CONNECTORS.find((x) => {
+        if (x.options.baseUrl === options.baseUrl) {
+            if (options.auth) {
+                if (x.options.auth) {
+                    return objectDeepEqual(x.options.auth, options.auth);
+                }
+            }
+            else {
+                // if auth not in find options; use first connector with same url
+                return true;
+            }
+        }
+    });
+}
+function removeConnector(connector) {
+    const index = CONNECTORS.indexOf(connector);
+    if (index !== -1) {
+        CONNECTORS.splice(index, 1);
+    }
 }
 
-function apiRequest(opt) {
-    var params = opt.params;
-    return new CancelablePromise(function (resolve, reject) {
-        opt.connector
-            .connect()
-            .then(function (apiItems) {
-            var apiItem = apiItems && apiItems[opt.name];
-            if (apiItem) {
-                apiItem = __spreadArray([], apiItem, true);
-                var url = apiItem.shift();
-                if (apiItem.length) {
-                    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');
-                        }
-                    }
-                    if (url) {
-                        url = template(url, replaceParams);
-                    }
-                }
-                // Transfer part of the parameters from `params` to the URL string
-                if (params) {
-                    var paramArray_1 = [];
-                    var paramList = params.paramList;
-                    if (Array.isArray(paramList)) {
-                        delete params.paramList;
-                        paramList.forEach(function (x) {
-                            paramArray_1.push("".concat(x[0], "=").concat(x[1]));
-                        });
-                    }
-                    for (var p in params) {
-                        if (apiItem.indexOf(p) === -1) {
-                            paramArray_1.push("".concat(p, "=").concat(params[p]));
-                        }
-                    }
-                    if (paramArray_1.length) {
-                        url = url + '?' + paramArray_1.join('&');
-                    }
-                }
-                if (url) {
-                    resolve(opt.connector.makeQuery(url, params, opt.requestOptions));
-                }
-                else {
-                    reject(new Error('request url is not set'));
-                }
-            }
-            else {
-                resolve(undefined);
-            }
-        })
-            .catch(function (er) {
-            reject(er);
-        });
-    });
+const exclude = ['description'];
+/**
+ * @remarks
+ * https://docs.nextgis.ru/docs_ngweb_dev/doc/developer/resource.html#search-resources
+ *
+ * ```
+ * { keyname, owner_user: { id }} > { keyname, owner_user__id }
+ * ```
+ *
+ * @param resource - Any property from NGW resource item
+ */
+function resourceToQuery(resource, prefix = '') {
+    prefix = prefix ? prefix + '__' : '';
+    const query = {};
+    for (const [key, value] of Object.entries(resource)) {
+        if (exclude.indexOf(key) === -1) {
+            if (isObject(value)) {
+                if (key === 'owner_user') {
+                    const children = resourceToQuery(value, key);
+                    Object.assign(query, children);
+                }
+                else if (key === 'parent' && 'id' in value) {
+                    query.parent_id = value.id;
+                }
+            }
+            else if (defined(value)) {
+                query[prefix + key] = value;
+            }
+        }
+    }
+    return query;
 }
 
-/**
- * Thrown when ...
- */
-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 ...
- */
-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));
-
-var CONNECTORS = [];
-function addConnector(connector) {
-    CONNECTORS.push(connector);
-}
-function findConnector(options) {
-    return CONNECTORS.find(function (x) {
-        if (x.options.baseUrl === options.baseUrl) {
-            if (options.auth) {
-                if (x.options.auth) {
-                    return objectDeepEqual(x.options.auth, options.auth);
-                }
-            }
-            else {
-                // if auth not in find options; use first connector with same url
-                return true;
-            }
-        }
-    });
-}
-function removeConnector(connector) {
-    var index = CONNECTORS.indexOf(connector);
-    if (index !== -1) {
-        CONNECTORS.splice(index, 1);
-    }
+function resourceCompare(res1, res2) {
+    return objectDeepEqual(res1, res2);
 }
 
-var exclude = ['description'];
-/**
- * @remarks
- * https://docs.nextgis.ru/docs_ngweb_dev/doc/developer/resource.html#search-resources
- *
- * ```
- * { keyname, owner_user: { id }} > { keyname, owner_user__id }
- * ```
- *
- * @param resource - Any property from NGW resource item
- */
-function resourceToQuery(resource, prefix) {
-    if (prefix === void 0) { prefix = ''; }
-    prefix = prefix ? prefix + '__' : '';
-    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') {
-                    var children = resourceToQuery(value, key);
-                    Object.assign(query, children);
-                }
-                else if (key === 'parent' && 'id' in value) {
-                    query.parent_id = value.id;
-                }
-            }
-            else if (defined(value)) {
-                query[prefix + key] = value;
-            }
-        }
-    }
-    return query;
+class ResourcesControl {
+    constructor(connector) {
+        this.connector = connector;
+        this.cache = new Cache();
+    }
+    // -------------------------------------------------------------------------
+    // Resource Methods
+    // -------------------------------------------------------------------------
+    /**
+     * Receive resource from NGW by id, keyname or search-object parameter.
+     * @param resource - Resource id, keyname or search-object
+     *
+     * @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 };
+        if (typeof resource === 'string') {
+            forCache.keyname = resource;
+        }
+        else if (typeof resource === 'number') {
+            forCache.id = resource;
+        }
+        else if (isObject(resource)) {
+            if (resource.id !== undefined) {
+                forCache.id = resource.id;
+            }
+            else if (resource.keyname) {
+                forCache.keyname = resource.keyname;
+            }
+        }
+        const makeRequest = () => {
+            if (typeof resource === 'string') {
+                return this._fetchResourceBy({ keyname: resource }, opt);
+            }
+            else if (typeof resource === 'number') {
+                return this._fetchResourceById(resource, opt);
+            }
+            else if (isObject(resource)) {
+                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) => {
+            if (res) {
+                return res;
+            }
+            throw new ResourceNotFoundError();
+        });
+    }
+    /**
+     * A fast way to retrieve resource ID for any resource definition.
+     * @param resource - Any available resource definition
+     *
+     * @remarks
+     * There are situations when exactly the resource id is needed
+     * (for example, to compose the correct request to the api)
+     * 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) {
+        if (typeof resource === 'number') {
+            return CancelablePromise.resolve(resource);
+        }
+        else if (typeof resource === 'string' || isObject(resource)) {
+            return this.getOne(resource, requestOptions).then((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
+     *
+     * @remarks
+     * 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) => {
+            if (resp === undefined) {
+                throw new Error();
+            }
+            return resp;
+        });
+    }
+    getMany(resource, requestOptions) {
+        return this._resourceCacheFilter(resource).then((items) => {
+            if (!items.length) {
+                const 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) => {
+                    if (resources) {
+                        for (const x of resources) {
+                            this.cache.add('resource.item', CancelablePromise.resolve(x), {
+                                id: x.resource.id,
+                            });
+                        }
+                    }
+                    return resources;
+                });
+            }
+            return items;
+        });
+    }
+    getParent(resource, requestOptions) {
+        return this.getOne(resource, requestOptions).then((child) => {
+            if (child) {
+                return this.getOne(child.resource.parent.id, requestOptions);
+            }
+            return CancelablePromise.resolve(undefined);
+        });
+    }
+    getChildrenOf(resource, requestOptions) {
+        return this.getIdOrFail(resource).then((parent) => this._getChildrenOf(parent, requestOptions));
+    }
+    update(resource, data) {
+        return this.getId(resource).then((id) => {
+            if (id !== undefined) {
+                return this.connector.put('resource.item', { data }, { id });
+            }
+        });
+    }
+    /**
+     * Fast way to delete resource from NGW and clean cache.
+     * @param resource - Resource definition
+     */
+    delete(resource) {
+        return this.getId(resource).then((id) => {
+            if (id !== undefined) {
+                return this.connector.delete('resource.item', null, { id }).then(() => {
+                    this._cleanResourceItemCache(id);
+                    return undefined;
+                });
+            }
+        });
+    }
+    _getChildrenOf(parent, requestOptions, _items = []) {
+        return this.connector
+            .get('resource.collection', { cache: true, ...requestOptions }, {
+            parent,
+        })
+            .then((items) => {
+            const recursivePromises = [];
+            for (const item of items) {
+                this.cache.add('resource.item', CancelablePromise.resolve(item), {
+                    id: item.resource.id,
+                });
+                _items.push(item);
+                if ((requestOptions === null || requestOptions === void 0 ? void 0 : requestOptions.recursive) && item.resource.children) {
+                    recursivePromises.push(this._getChildrenOf(item.resource.id, requestOptions, _items));
+                }
+            }
+            if (recursivePromises.length) {
+                return CancelablePromise.all(recursivePromises).then(() => {
+                    return _items;
+                });
+            }
+            return _items;
+        });
+    }
+    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);
+                    }
+                }
+            }
+        }
+        for (const d of toDelete) {
+            this.cache.delete(d);
+        }
+    }
+    _fetchResourceById(id, requestOptions) {
+        const promise = () => this.connector.get('resource.item', requestOptions, { id });
+        return this.cache
+            .add('resource.item', promise, {
+            id,
+        })
+            .catch((er) => {
+            if (!(er instanceof ResourceNotFoundError)) {
+                throw er;
+            }
+            return undefined;
+        });
+    }
+    _fetchResourceBy(resource, requestOptions) {
+        return this.getMany(resource, requestOptions).then((resources) => {
+            return resources[0];
+        });
+    }
+    _resourceCacheFilter(resource) {
+        return CancelablePromise.all(this.cache.matchAll('resource.item')).then((resources) => {
+            const items = [];
+            resources.filter((x) => {
+                if (x) {
+                    // identical by uniq props
+                    if (resource.keyname && x.resource.keyname) {
+                        return resource.keyname === x.resource.keyname;
+                    }
+                    if (defined(resource.id) && defined(x.resource.id)) {
+                        return resource.id === x.resource.id;
+                    }
+                    return resourceCompare(resource, x.resource);
+                }
+            });
+            return items;
+        });
+    }
 }
 
-function resourceCompare(res1, res2) {
-    return objectDeepEqual(res1, res2);
+let ID = 0;
+class NgwConnector$1 {
+    constructor(options) {
+        this.options = options;
+        this.id = ID++;
+        this.emitter = new events.exports.EventEmitter();
+        this.routeStr = '/api/component/pyramid/route';
+        this.activeRequests = [];
+        const exist = findConnector(options);
+        if (exist) {
+            return exist;
+        }
+        else {
+            if (this.options.route) {
+                this.routeStr = this.options.route;
+            }
+            if (this.options.requestTransform) {
+                this.requestTransform = this.options.requestTransform;
+            }
+            this.resources = new ResourcesControl(this);
+            addConnector(this);
+        }
+    }
+    static create(options) {
+        return new this(options);
+    }
+    setRequestTransform(requestTransform) {
+        this.requestTransform = requestTransform;
+    }
+    /**
+     * Fast way to specify the connection address to NextGIS Web.
+     * The current connection will be severed.
+     * @param baseUrl - NGW url
+     */
+    setNgw(baseUrl) {
+        this.logout();
+        this.options.baseUrl = baseUrl;
+        addConnector(this);
+    }
+    /**
+     * Establishing a connection with NextGIS Web to fulfill all other requests.
+     * @remarks
+     * This method need not be called manually as it is used when forming a request in {@link apiRequest | apiRequest}.
+     * Can be used to check connection.
+     * @example
+     * ```javascript
+     * const connector = new NgwConnector({baseUrl: 'https://demo.nextgis.com'});
+     * connector.connect()
+     *   .then(() => console.log('Ok'))
+     *   .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._login({ login, password })
+                        .then(() => {
+                        return makeQuery();
+                    })
+                        .catch((er) => reject(er));
+                }
+            }
+            return makeQuery();
+        });
+        return cache.add('route', makeConnect, {
+            id: this.id,
+            auth,
+            baseUrl: this.options.baseUrl,
+        });
+    }
+    /**
+     * Quick way to change NextGIS Web user.
+     * @param credentials - New user credentials
+     */
+    login(credentials, options) {
+        this.logout();
+        addConnector(this);
+        return this._login(credentials, options);
+    }
+    /**
+     * Disconnecting a user. Aborting all current requests
+     */
+    logout() {
+        this.abort();
+        removeConnector(this);
+        this.options.auth = undefined;
+        this.user = undefined;
+        this.emitter.emit('logout');
+        this.resources.cache.clean();
+    }
+    getUserInfo(credentials, options) {
+        if (this.user && this.user.id) {
+            return CancelablePromise.resolve(this.user);
+        }
+        if (credentials) {
+            this.options.auth = credentials;
+        }
+        const options_ = {
+            headers: this.getAuthorizationHeaders(credentials),
+            // withCredentials: true
+            ...options,
+        };
+        // Do not use apiRequest('auth.current_user') to avoid circular-references
+        return this.makeQuery('/api/component/auth/current_user', {}, options_);
+    }
+    /**
+     * Obtaining the required Headers for authentication of requests in the NGW.
+     */
+    getAuthorizationHeaders(credentials) {
+        const client = this.makeClientId(credentials);
+        if (client) {
+            return {
+                Authorization: 'Basic ' + client,
+            };
+        }
+    }
+    makeClientId(credentials) {
+        credentials = credentials || this.options.auth;
+        if (credentials) {
+            const { login, password } = credentials;
+            const str = unescape(encodeURIComponent(`${login}:${password}`));
+            // @ts-ignore
+            {
+                return window.btoa(str);
+            }
+        }
+    }
+    /** Stop all api requests */
+    abort() {
+        for (const req of this.activeRequests) {
+            req.cancel();
+        }
+        this.activeRequests = [];
+    }
+    getActiveApiRequests() {
+        return [...this.activeRequests];
+    }
+    /**
+     * 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}
+     * @param params - Request item params or query params
+     * @param requestOptions - Request options
+     *
+     * @example
+     * ```javascript
+     *
+     * // there is such an NGW route item
+     * // "feature_layer.feature.item": [
+     * //   "/api/resource/{0}/feature/{1}",
+     * //   "id",
+     * //   "fid"
+     * // ],
+     *
+     * const connector = new NgwConnector({ baseUrl: 'https://example.nextgis.com' });
+     * connector.apiRequest('feature_layer.feature.item', {
+     *   // request params for {0} and {1}
+     *   'id': 2011,
+     *   'fid': 101,
+     *   // query params
+     *   'srs': 4326,
+     *   'geom_format': 'geojson',
+     * }, { method: 'GET' });
+     * // send get-request to 'https://example.nextgis.com/api/resource/2011/feature/101?srs=4326&geom_format=geojson'
+     *
+     * ```
+     */
+    apiRequest(name, params_ = {}, requestOptions = {}) {
+        var _a;
+        const { method, headers, withCredentials, responseType } = requestOptions;
+        const params = objectRemoveEmpty(params_);
+        const makeApiRequest = () => apiRequest({ name, params, 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,
+                    userId: (_a = this.user) === null || _a === void 0 ? void 0 : _a.id,
+                }),
+            });
+        }
+        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}
+     * @param options - Request options
+     * @param params - Request item params or query params
+     *
+     * @example
+     * ```javascript
+     * connector.post('resource.collection', { data: POST_PAYLOAD })
+     *   .then((newResource) => console.log(newResource))
+     *   .catch((error) => console.warn(error));
+     * ```
+     */
+    post(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) {
+        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) {
+        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) {
+        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) {
+        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 = {}) {
+        url = (this.options.baseUrl ? this.options.baseUrl : '') + url;
+        if (url) {
+            if (params) {
+                url = template(url, params);
+            }
+            url = encodeURI(fixUrlStr(url));
+            return this._loadData(url, options);
+        }
+        else {
+            throw new Error('Empty `url` not allowed');
+        }
+    }
+    // -------------------------------------------------------------------------
+    // Resource Methods
+    // -------------------------------------------------------------------------
+    /**
+     * {@link ResourcesControl.getOne}
+     */
+    getResource(resource, requestOptions) {
+        return this.resources.getOne(resource, requestOptions);
+    }
+    /**
+     * {@link ResourcesControl.getOneOrFail}
+     */
+    getResourceOrFail(resource, requestOptions) {
+        return this.resources.getOneOrFail(resource, requestOptions);
+    }
+    /**
+     * @deprecated - use {@link getResource}
+     */
+    getResourceBy(resource) {
+        return this.resources.getOne(resource);
+    }
+    /**
+     * @deprecated - use {@link getResource}
+     */
+    getResourceByKeyname(keyname) {
+        return this.resources.getOne(keyname);
+    }
+    /**
+     * @deprecated - use {@link getResource}
+     */
+    getResourceById(id) {
+        return this.resources.getOne(id);
+    }
+    /**
+     * {@link ResourcesControl.getId}
+     */
+    getResourceId(resource, requestOptions) {
+        return this.resources.getId(resource, requestOptions);
+    }
+    /**
+     * {@link ResourcesControl.getIdOrFail}
+     */
+    getResourceIdOrFail(resource, requestOptions) {
+        return this.resources.getIdOrFail(resource, requestOptions);
+    }
+    /**
+     * {@link ResourcesControl.getMany}
+     */
+    getResourcesBy(resource, requestOptions) {
+        return this.resources.getMany(resource, requestOptions);
+    }
+    /**
+     * {@link ResourcesControl.getParent}
+     */
+    getResourceParent(resource, requestOptions) {
+        return this.resources.getParent(resource, requestOptions);
+    }
+    /**
+     * {@link ResourcesControl.getChildrenOf}
+     */
+    getResourceChildren(resource, requestOptions) {
+        return this.resources.getChildrenOf(resource, requestOptions);
+    }
+    /**
+     * {@link ResourcesControl.update}
+     */
+    updateResource(resource, data) {
+        return this.resources.update(resource, data);
+    }
+    /**
+     * {@link ResourcesControl.delete}
+     */
+    deleteResource(resource) {
+        return this.resources.delete(resource);
+    }
+    /**
+     * @internal
+     */
+    _loadData(url, options) {
+        options.responseType = options.responseType || 'json';
+        const request = new CancelablePromise((resolve, reject, onCancel) => {
+            if (this.user) {
+                options = options || {};
+                // options.withCredentials = true;
+                options.headers = {
+                    ...this.getAuthorizationHeaders(),
+                    ...options.headers,
+                };
+            }
+            if (this.requestTransform) {
+                const [transUrl, transOptions] = this.requestTransform(url, options);
+                url = transUrl;
+                options = transOptions;
+            }
+            loadData(url, resolve, options, reject, onCancel);
+        })
+            .then((resp) => {
+            this._cleanActiveRequests(request);
+            return resp;
+        })
+            .catch((httpError) => {
+            this._cleanActiveRequests(request);
+            if (httpError instanceof CancelablePromise.CancelError) ;
+            else {
+                // @ts-ignore
+                {
+                    console.warn('DEV WARN', httpError);
+                }
+                const er = this._handleHttpError(httpError);
+                if (er) {
+                    throw er;
+                }
+            }
+        });
+        if (options.signal &&
+            typeof options.signal.addEventListener === 'function') {
+            options.signal.addEventListener('abort', () => {
+                request.cancel();
+                this._cleanActiveRequests(request);
+            });
+        }
+        this.activeRequests.push(request);
+        return request;
+    }
+    _login(credentials, options) {
+        return this.getUserInfo(credentials, options)
+            .then((data) => {
+            this.user = data;
+            this.emitter.emit('login', data);
+            return data;
+        })
+            .catch((er) => {
+            this.emitter.emit('login:error', er);
+            throw er;
+        });
+    }
+    _cleanActiveRequests(request) {
+        const activeRequestIndex = this.activeRequests.indexOf(request);
+        if (activeRequestIndex !== -1) {
+            this.activeRequests.splice(activeRequestIndex, 1);
+        }
+    }
+    _handleHttpError(er) {
+        if (er) {
+            if (er instanceof NgwError) {
+                if (er.exception === 'nextgisweb.resource.exception.ResourceNotFound') {
+                    throw new ResourceNotFoundError(er);
+                }
+                else if (er.exception === 'nextgisweb.core.exception.InsufficientPermissions') {
+                    throw new InsufficientPermissionsError(er);
+                }
+            }
+        }
+        return er;
+    }
 }
+NgwConnector$1.errors = {
+    NgwError,
+    ResourceNotFoundError,
+};
 
-var ResourcesControl = /** @class */ (function () {
-    function ResourcesControl(connector) {
-        this.connector = connector;
-        this.cache = new Cache();
-    }
-    // -------------------------------------------------------------------------
-    // Resource Methods
-    // -------------------------------------------------------------------------
-    /**
-     * Receive resource from NGW by id, keyname or search-object parameter.
-     * @param resource - Resource id, keyname or search-object
-     *
-     * @remarks
-     * Fetching resource would be cached to speed up next call
-     */
-    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;
-        }
-        else if (typeof resource === 'number') {
-            forCache.id = resource;
-        }
-        else if (isObject(resource)) {
-            if (resource.id !== undefined) {
-                forCache.id = resource.id;
-            }
-            else if (resource.keyname) {
-                forCache.keyname = resource.keyname;
-            }
-        }
-        var makeRequest = function () {
-            if (typeof resource === 'string') {
-                return _this._fetchResourceBy({ keyname: resource }, opt);
-            }
-            else if (typeof resource === 'number') {
-                return _this._fetchResourceById(resource, opt);
-            }
-            else if (isObject(resource)) {
-                return _this._fetchResourceBy(resource, opt);
-            }
-            return CancelablePromise.resolve(undefined);
-        };
-        return cache.addFull('resource', makeRequest, forCache);
-    };
-    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
-     *
-     * @remarks
-     * There are situations when exactly the resource id is needed
-     * (for example, to compose the correct request to the api)
-     * 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.
-     */
-    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(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
-     *
-     * @remarks
-     * 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
-     */
-    ResourcesControl.prototype.getIdOrFail = function (resource, requestOptions) {
-        return this.getId(resource, requestOptions).then(function (resp) {
-            if (resp === undefined) {
-                throw new Error();
-            }
-            return resp;
-        });
-    };
-    ResourcesControl.prototype.getMany = function (resource, requestOptions) {
-        var _this = this;
-        return this._resourceCacheFilter(resource).then(function (items) {
-            if (!items.length) {
-                var query = {};
-                if (resource.keyname) {
-                    query.keyname = resource.keyname;
-                }
-                else {
-                    Object.assign(query, resourceToQuery(resource));
-                }
-                return _this.connector
-                    .get('resource.search', requestOptions, __assign({ serialization: 'full' }, query))
-                    .then(function (resources) {
-                    if (resources) {
-                        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,
-                            });
-                        }
-                    }
-                    return resources;
-                });
-            }
-            return items;
-        });
-    };
-    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 CancelablePromise.resolve(undefined);
-        });
-    };
-    ResourcesControl.prototype.getChildrenOf = function (resource, requestOptions) {
-        var _this = this;
-        return this.getIdOrFail(resource).then(function (parent) {
-            return _this._getChildrenOf(parent, requestOptions);
-        });
-    };
-    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: data }, { id: id });
-            }
-        });
-    };
-    /**
-     * Fast way to delete resource from NGW and clean cache.
-     * @param resource - Resource definition
-     */
-    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: id }).then(function () {
-                    _this._cleanResourceItemCache(id);
-                    return undefined;
-                });
-            }
-        });
-    };
-    ResourcesControl.prototype._getChildrenOf = function (parent, requestOptions, _items) {
-        var _this = this;
-        if (_items === void 0) { _items = []; }
-        return this.connector
-            .get('resource.collection', __assign({ cache: true }, requestOptions), {
-            parent: parent,
-        })
-            .then(function (items) {
-            var recursivePromises = [];
-            for (var _i = 0, items_1 = items; _i < items_1.length; _i++) {
-                var item = items_1[_i];
-                _this.cache.add('resource.item', CancelablePromise.resolve(item), {
-                    id: item.resource.id,
-                });
-                _items.push(item);
-                if ((requestOptions === null || requestOptions === void 0 ? void 0 : requestOptions.recursive) && item.resource.children) {
-                    recursivePromises.push(_this._getChildrenOf(item.resource.id, requestOptions, _items));
-                }
-            }
-            if (recursivePromises.length) {
-                return CancelablePromise.all(recursivePromises).then(function () {
-                    return _items;
-                });
-            }
-            return _items;
-        });
-    };
-    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*/];
-                }
-            });
-        });
-    };
-    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,
-        })
-            .catch(function (er) {
-            if (!(er instanceof ResourceNotFoundError)) {
-                throw er;
-            }
-            return undefined;
-        });
-    };
-    ResourcesControl.prototype._fetchResourceBy = function (resource, requestOptions) {
-        return this.getMany(resource, requestOptions).then(function (resources) {
-            return resources[0];
-        });
-    };
-    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) {
-                        return resource.keyname === x.resource.keyname;
-                    }
-                    if (defined(resource.id) && defined(x.resource.id)) {
-                        return resource.id === x.resource.id;
-                    }
-                    return resourceCompare(resource, x.resource);
-                }
-            });
-            return items;
-        });
-    };
-    return ResourcesControl;
-}());
-
-var ID = 0;
-var NgwConnector$1 = /** @class */ (function () {
-    function NgwConnector(options) {
-        this.options = options;
-        this.id = ID++;
-        this.emitter = new events.exports.EventEmitter();
-        this.routeStr = '/api/component/pyramid/route';
-        this.activeRequests = [];
-        var exist = findConnector(options);
-        if (exist) {
-            return exist;
-        }
-        else {
-            if (this.options.route) {
-                this.routeStr = this.options.route;
-            }
-            if (this.options.requestTransform) {
-                this.requestTransform = this.options.requestTransform;
-            }
-            this.resources = new ResourcesControl(this);
-            addConnector(this);
-        }
-    }
-    NgwConnector.create = function (options) {
-        return new this(options);
-    };
-    NgwConnector.prototype.setRequestTransform = function (requestTransform) {
-        this.requestTransform = requestTransform;
-    };
-    /**
-     * Fast way to specify the connection address to NextGIS Web.
-     * The current connection will be severed.
-     * @param baseUrl - NGW url
-     */
-    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
-     * This method need not be called manually as it is used when forming a request in {@link apiRequest | apiRequest}.
-     * Can be used to check connection.
-     * @example
-     * ```javascript
-     * const connector = new NgwConnector({baseUrl: 'https://demo.nextgis.com'});
-     * connector.connect()
-     *   .then(() => console.log('Ok'))
-     *   .catch((er) => console.log('Connection problem', er));
-     * ```
-     */
-    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(function (er) {
-                        reject(er);
-                    });
-                };
-                if (auth) {
-                    var login = auth.login, password = auth.password;
-                    if (login && password) {
-                        return _this._login({ login: login, password: password })
-                            .then(function () {
-                            return makeQuery();
-                        })
-                            .catch(function (er) { return reject(er); });
-                    }
-                }
-                return makeQuery();
-            });
-        };
-        return cache.add('route', makeConnect, {
-            id: this.id,
-            auth: auth,
-            baseUrl: this.options.baseUrl,
-        });
-    };
-    /**
-     * Quick way to change NextGIS Web user.
-     * @param credentials - New user credentials
-     */
-    NgwConnector.prototype.login = function (credentials, options) {
-        this.logout();
-        addConnector(this);
-        return this._login(credentials, options);
-    };
-    /**
-     * Disconnecting a user. Aborting all current requests
-     */
-    NgwConnector.prototype.logout = function () {
-        this.abort();
-        removeConnector(this);
-        this.options.auth = undefined;
-        this.user = undefined;
-        this.emitter.emit('logout');
-        this.resources.cache.clean();
-    };
-    NgwConnector.prototype.getUserInfo = function (credentials, options) {
-        if (this.user && this.user.id) {
-            return CancelablePromise.resolve(this.user);
-        }
-        if (credentials) {
-            this.options.auth = credentials;
-        }
-        var options_ = __assign({ headers: this.getAuthorizationHeaders(credentials) }, options);
-        // Do not use apiRequest('auth.current_user') to avoid circular-references
-        return this.makeQuery('/api/component/auth/current_user', {}, options_);
-    };
-    /**
-     * Obtaining the required Headers for authentication of requests in the NGW.
-     */
-    NgwConnector.prototype.getAuthorizationHeaders = function (credentials) {
-        var client = this.makeClientId(credentials);
-        if (client) {
-            return {
-                Authorization: 'Basic ' + client,
-            };
-        }
-    };
-    NgwConnector.prototype.makeClientId = function (credentials) {
-        credentials = credentials || this.options.auth;
-        if (credentials) {
-            var login = credentials.login, password = credentials.password;
-            var str = unescape(encodeURIComponent("".concat(login, ":").concat(password)));
-            // @ts-ignore
-            {
-                return window.btoa(str);
-            }
-        }
-    };
-    /** Stop all api requests */
-    NgwConnector.prototype.abort = function () {
-        for (var _i = 0, _a = this.activeRequests; _i < _a.length; _i++) {
-            var req = _a[_i];
-            req.cancel();
-        }
-        this.activeRequests = [];
-    };
-    NgwConnector.prototype.getActiveApiRequests = function () {
-        return __spreadArray([], this.activeRequests, true);
-    };
-    /**
-     * 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}
-     * @param params - Request item params or query params
-     * @param requestOptions - Request options
-     *
-     * @example
-     * ```javascript
-     *
-     * // there is such an NGW route item
-     * // "feature_layer.feature.item": [
-     * //   "/api/resource/{0}/feature/{1}",
-     * //   "id",
-     * //   "fid"
-     * // ],
-     *
-     * const connector = new NgwConnector({ baseUrl: 'https://example.nextgis.com' });
-     * connector.apiRequest('feature_layer.feature.item', {
-     *   // request params for {0} and {1}
-     *   'id': 2011,
-     *   'fid': 101,
-     *   // query params
-     *   'srs': 4326,
-     *   'geom_format': 'geojson',
-     * }, { method: 'GET' });
-     * // send get-request to 'https://example.nextgis.com/api/resource/2011/feature/101?srs=4326&geom_format=geojson'
-     *
-     * ```
-     */
-    NgwConnector.prototype.apiRequest = function (name, params_, requestOptions) {
-        var _this = this;
-        var _a;
-        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') {
-            var cache = new Cache();
-            return cache.add(name, makeApiRequest, __assign({ params: params }, objectRemoveEmpty({
-                headers: headers,
-                withCredentials: withCredentials,
-                responseType: responseType,
-                baseUrl: this.options.baseUrl,
-                userId: (_a = this.user) === null || _a === void 0 ? void 0 : _a.id,
-            })));
-        }
-        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}
-     * @param options - Request options
-     * @param params - Request item params or query params
-     *
-     * @example
-     * ```javascript
-     * connector.post('resource.collection', { data: POST_PAYLOAD })
-     *   .then((newResource) => console.log(newResource))
-     *   .catch((error) => console.warn(error));
-     * ```
-     */
-    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
-     */
-    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
-     */
-    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
-     */
-    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
-     */
-    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
-     */
-    NgwConnector.prototype.makeQuery = function (url, params, options) {
-        if (options === void 0) { options = {}; }
-        url = (this.options.baseUrl ? this.options.baseUrl : '') + url;
-        if (url) {
-            if (params) {
-                url = template(url, params);
-            }
-            url = encodeURI(fixUrlStr(url));
-            return this._loadData(url, options);
-        }
-        else {
-            throw new Error('Empty `url` not allowed');
-        }
-    };
-    // -------------------------------------------------------------------------
-    // Resource Methods
-    // -------------------------------------------------------------------------
-    /**
-     * {@link ResourcesControl.getOne}
-     */
-    NgwConnector.prototype.getResource = function (resource, requestOptions) {
-        return this.resources.getOne(resource, requestOptions);
-    };
-    /**
-     * {@link ResourcesControl.getOneOrFail}
-     */
-    NgwConnector.prototype.getResourceOrFail = function (resource, requestOptions) {
-        return this.resources.getOneOrFail(resource, requestOptions);
-    };
-    /**
-     * @deprecated - use {@link getResource}
-     */
-    NgwConnector.prototype.getResourceBy = function (resource) {
-        return this.resources.getOne(resource);
-    };
-    /**
-     * @deprecated - use {@link getResource}
-     */
-    NgwConnector.prototype.getResourceByKeyname = function (keyname) {
-        return this.resources.getOne(keyname);
-    };
-    /**
-     * @deprecated - use {@link getResource}
-     */
-    NgwConnector.prototype.getResourceById = function (id) {
-        return this.resources.getOne(id);
-    };
-    /**
-     * {@link ResourcesControl.getId}
-     */
-    NgwConnector.prototype.getResourceId = function (resource, requestOptions) {
-        return this.resources.getId(resource, requestOptions);
-    };
-    /**
-     * {@link ResourcesControl.getIdOrFail}
-     */
-    NgwConnector.prototype.getResourceIdOrFail = function (resource, requestOptions) {
-        return this.resources.getIdOrFail(resource, requestOptions);
-    };
-    /**
-     * {@link ResourcesControl.getMany}
-     */
-    NgwConnector.prototype.getResourcesBy = function (resource, requestOptions) {
-        return this.resources.getMany(resource, requestOptions);
-    };
-    /**
-     * {@link ResourcesControl.getParent}
-     */
-    NgwConnector.prototype.getResourceParent = function (resource, requestOptions) {
-        return this.resources.getParent(resource, requestOptions);
-    };
-    /**
-     * {@link ResourcesControl.getChildrenOf}
-     */
-    NgwConnector.prototype.getResourceChildren = function (resource, requestOptions) {
-        return this.resources.getChildrenOf(resource, requestOptions);
-    };
-    /**
-     * {@link ResourcesControl.update}
-     */
-    NgwConnector.prototype.updateResource = function (resource, data) {
-        return this.resources.update(resource, data);
-    };
-    /**
-     * {@link ResourcesControl.delete}
-     */
-    NgwConnector.prototype.deleteResource = function (resource) {
-        return this.resources.delete(resource);
-    };
-    /**
-     * @internal
-     */
-    NgwConnector.prototype._loadData = function (url, options) {
-        var _this = this;
-        options.responseType = options.responseType || 'json';
-        var request = new CancelablePromise(function (resolve, reject, onCancel) {
-            if (_this.user) {
-                options = options || {};
-                // options.withCredentials = true;
-                options.headers = __assign(__assign({}, _this.getAuthorizationHeaders()), options.headers);
-            }
-            if (_this.requestTransform) {
-                var _a = _this.requestTransform(url, options), transUrl = _a[0], transOptions = _a[1];
-                url = transUrl;
-                options = transOptions;
-            }
-            loadData(url, resolve, options, reject, onCancel);
-        })
-            .then(function (resp) {
-            _this._cleanActiveRequests(request);
-            return resp;
-        })
-            .catch(function (httpError) {
-            _this._cleanActiveRequests(request);
-            if (httpError instanceof CancelablePromise.CancelError) ;
-            else {
-                // @ts-ignore
-                {
-                    console.warn('DEV WARN', httpError);
-                }
-                var er = _this._handleHttpError(httpError);
-                if (er) {
-                    throw er;
-                }
-            }
-        });
-        if (options.signal &&
-            typeof options.signal.addEventListener === 'function') {
-            options.signal.addEventListener('abort', function () {
-                request.cancel();
-                _this._cleanActiveRequests(request);
-            });
-        }
-        this.activeRequests.push(request);
-        return request;
-    };
-    NgwConnector.prototype._login = function (credentials, options) {
-        var _this = this;
-        return this.getUserInfo(credentials, options)
-            .then(function (data) {
-            _this.user = data;
-            _this.emitter.emit('login', data);
-            return data;
-        })
-            .catch(function (er) {
-            _this.emitter.emit('login:error', er);
-            throw er;
-        });
-    };
-    NgwConnector.prototype._cleanActiveRequests = function (request) {
-        var activeRequestIndex = this.activeRequests.indexOf(request);
-        if (activeRequestIndex !== -1) {
-            this.activeRequests.splice(activeRequestIndex, 1);
-        }
-    };
-    NgwConnector.prototype._handleHttpError = function (er) {
-        if (er) {
-            if (er instanceof NgwError) {
-                if (er.exception === 'nextgisweb.resource.exception.ResourceNotFound') {
-                    throw new ResourceNotFoundError(er);
-                }
-                else if (er.exception === 'nextgisweb.core.exception.InsufficientPermissions') {
-                    throw new InsufficientPermissionsError(er);
-                }
-            }
-        }
-        return er;
-    };
-    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
- *
- * @remarks
- * Make sure CORS is registered in the {@link https://docs.nextgis.com/docs_ngcom/source/CORS.html | NextGIS Web settings } to be able to send requests.
- *
- * @packageDocumentation
- * @module ngw-connector
- */
+/**
+ * A lightweight HTTP client optimized for use with {@link http://docs.nextgis.ru/docs_ngweb_dev/doc/developer/toc.html | NextGIS Web} API
+ *
+ * @remarks
+ * Make sure CORS is registered in the {@link https://docs.nextgis.com/docs_ngcom/source/CORS.html | NextGIS Web settings } to be able to send requests.
+ *
+ * @packageDocumentation
+ * @module ngw-connector
+ */
 var NgwConnector = NgwConnector$1;
 
 export { NgwConnector as default };