@nextgis/ngw-connector 1.18.21 → 1.19.0

package/lib/ngw-connector.global.js

@@ -1,4 +1,4 @@
-/** Bundle of @nextgis/ngw-connector; version: 1.18.21; author: NextGIS */
+/** Bundle of @nextgis/ngw-connector; version: 1.19.0; author: NextGIS */
 var NgwConnector = (function () {
     'use strict';
 
@@ -573,663 +573,648 @@ var NgwConnector = (function () {
       }
     }
 
-    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));
+    /**
+     * 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);
+    }
 
-    var PromiseControl = /** @class */ (function () {
-        function PromiseControl(options) {
-            if (options === void 0) { options = {}; }
-            this.options = options;
-            this._promises = new Map();
+    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('');
         }
-        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();
+        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;
             }
-            if (exist) {
-                return exist;
+            else {
+                return objectDeepEqual(a, b);
             }
-            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();
+        }
+        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;
             }
-        };
-        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 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]);
             }
-            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();
+            else if (obj[key] !== undefined) {
+                newObj[key] = obj[key];
             }
-        };
-        return PromiseControl;
-    }());
+        });
+        return newObj;
+    }
 
-    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));
+    function fixUrlStr(url) {
+        // remove double slash
+        return url.replace(/([^:]\/)\/+/g, '$1');
+    }
 
-    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 cache1 = new Cache();
+     * cache1.add('foo', 'value');
      *
-     * const promise = new CancelablePromise((resolve, reject) => {
-     *  setTimeout(() => resolve(), 100);
-     * }).catch((er) => {
-     *  if (er.name === "CancelError") {
-     *    // handle cancel error
-     *  }
-     *  throw er;
-     * });
+     * const cache2 = new Cache();
+     * cache2.match('foo'); // value
      *
-     * promise.cancel();
+     * const cache3 = new Cache({ namespace: 'foo' });
+     * cache3.match('foo'); // undefined
      * ```
+     *
      * @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();
+     * let COUNTER = 0;
+     * const createPromise = () => new Promise((res) => {
+     *   COUNTER++
+     *   setTimeout(() => res('Ok'), 300)
      * });
      *
-     * promise.cancel();
+     * 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 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);
-                }));
+    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];
             }
-            this._promise = Promise.race(promises);
+            Cache.instance[namespace] = this;
+            return this;
         }
-        CancelablePromise.createControl = function (opt) {
-            return new PromiseControl(opt);
+        Cache.prototype.clean = function () {
+            this.cache.length = 0;
         };
-        CancelablePromise.resolve = function (value) {
-            return new CancelablePromise(function (resolve) { return resolve(value); });
+        Cache.prototype.all = function () {
+            return this.cache;
         };
-        CancelablePromise.reject = function (value) {
-            return new CancelablePromise(function (resolve, reject) { return reject(value); });
+        /**
+         * 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);
         };
-        CancelablePromise.all = function (values) {
+        Cache.prototype.add = function (key, valueToSet, props, onlyFull) {
             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();
-                        }
+            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;
                 }
-                throw er;
-            });
-        };
-        CancelablePromise.prototype.attach = function (p) {
-            if (this._isCanceled) {
-                p.cancel();
+                return value;
             }
             else {
-                this._children.push(p);
+                return exist.value;
             }
         };
-        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());
+        Cache.prototype.match = function (key, props) {
+            var cacheRecord = this._find(key, props);
+            if (cacheRecord) {
+                return cacheRecord.value;
             }
-            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());
+        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 Promise.reject(onfinally);
+            return this.cache.map(function (x) { return x.value; });
         };
-        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();
+        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); });
             }
-            if (this._children) {
-                this._children.forEach(function (x) { return x.cancel(); });
+            else {
+                exist.push(keyOrItem);
             }
-            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();
-                }
+            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);
             }
-            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;
+        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 parent;
-        };
-        CancelablePromise.prototype._destroy = function () {
-            this._setCanceledCallback = undefined;
-            this._cancelPromise = undefined;
-            this._promise = undefined;
+            return false;
         };
-        CancelablePromise.CancelError = CancelError;
-        CancelablePromise.TimeoutError = TimeoutError;
-        CancelablePromise.PromiseControl = PromiseControl;
-        return CancelablePromise;
+        Cache.instance = {};
+        return Cache;
     }());
-    Object.setPrototypeOf(CancelablePromise$1.prototype, Promise.prototype);
-
-    /**
-     * 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.
+    /**
+     * Caching for asynchronous functions
      *
-     * @example
-     * ```javascript
-     * full('foo') // true
-     * full('') // false
-     * full(undefined) // false
-     * full(0) // true
-     * ```
+     * @packageDocumentation
+     * @module cache
      */
-    function full(val) {
-        return typeof val === 'string' ? !!val : defined(val);
-    }
+    var Cache = Cache$1;
 
-    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;
+    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;
         }
-        else if (a instanceof Function) {
-            if (!(b instanceof Function))
-                return false;
-            //ignore functions, or check them regardless?
+        return CancelError;
+    }(Error));
+
+    var PromiseControl = /** @class */ (function () {
+        function PromiseControl(options) {
+            if (options === void 0) { options = {}; }
+            this.options = options;
+            this._promises = new Map();
         }
-        else if (a instanceof Object) {
-            if (!(b instanceof Object))
-                return false;
-            if (a === o) {
-                return b === p;
+        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();
             }
-            else {
-                return objectDeepEqual(a, b);
+        };
+        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();
             }
-        }
-        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;
+            if (exist) {
+                return exist;
             }
-        }
-        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]);
+            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();
             }
-            else if (obj[key] !== undefined) {
-                newObj[key] = obj[key];
+        };
+        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 newObj;
-    }
+            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;
+    }());
 
-    function fixUrlStr(url) {
-        // remove double slash
-        return url.replace(/([^:]\/)\/+/g, '$1');
-    }
+    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
-     * const cache1 = new Cache();
-     * cache1.add('foo', 'value');
+     * import CancelablePromise from "@nextgis/cancelable-promise";
      *
-     * const cache2 = new Cache();
-     * cache2.match('foo'); // value
+     * const promise = new CancelablePromise((resolve, reject) => {
+     *  setTimeout(() => resolve(), 100);
+     * }).catch((er) => {
+     *  if (er.name === "CancelError") {
+     *    // handle cancel error
+     *  }
+     *  throw er;
+     * });
      *
-     * const cache3 = new Cache({ namespace: 'foo' });
-     * cache3.match('foo'); // undefined
+     * promise.cancel();
      * ```
-     *
      * @example
+     * Handle `onCancel` callback
      * ```javascript
-     * let COUNTER = 0;
-     * const createPromise = () => new Promise((res) => {
-     *   COUNTER++
-     *   setTimeout(() => res('Ok'), 300)
-     * });
+     * import CancelablePromise from "@nextgis/cancelable-promise";
      *
-     * const cache = new Cache();
-     * for (let i = 0; i < 10; i++) {
-     *   cache.add('foo', createPromise).then((data) => {
-     *     console.log(data); // 'Ok'
+     * 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();
      *   });
-     * }
-     * console.log(COUNTER); // 1
+     *
+     *   xhr.send();
+     * });
+     *
+     * promise.cancel();
      * ```
      */
-    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];
+    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);
+                }));
             }
-            Cache.instance[namespace] = this;
-            return this;
+            this._promise = Promise.race(promises);
         }
-        Cache.prototype.clean = function () {
-            this.cache.length = 0;
+        CancelablePromise.createControl = function (opt) {
+            return new PromiseControl(opt);
         };
-        Cache.prototype.all = function () {
-            return this.cache;
+        CancelablePromise.resolve = function (value) {
+            return new CancelablePromise(function (resolve) { return resolve(value); });
         };
-        /**
-         * 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);
+        CancelablePromise.reject = function (value) {
+            return new CancelablePromise(function (resolve, reject) { return reject(value); });
         };
-        Cache.prototype.add = function (key, valueToSet, props, onlyFull) {
+        CancelablePromise.all = function (values) {
             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 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();
+                        }
                     }
-                    return value;
                 }
-                return value;
+                throw er;
+            });
+        };
+        CancelablePromise.prototype.attach = function (p) {
+            if (this._isCanceled) {
+                p.cancel();
             }
             else {
-                return exist.value;
+                this._children.push(p);
             }
         };
-        Cache.prototype.match = function (key, props) {
-            var cacheRecord = this._find(key, props);
-            if (cacheRecord) {
-                return cacheRecord.value;
+        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);
         };
-        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; });
+        CancelablePromise.prototype.finally = function (onfinally) {
+            if (this._promise) {
+                return this._promise.finally(onfinally);
             }
-            return this.cache.map(function (x) { return x.value; });
+            if (this._isCanceled) {
+                return Promise.reject(new CancelError());
+            }
+            return Promise.reject(onfinally);
         };
-        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); });
+        CancelablePromise.prototype.cancel = function () {
+            // No reason to run cancel action if promise is already complete
+            if (this._isCanceled || !this._isPending) {
+                return this;
             }
-            else {
-                exist.push(keyOrItem);
+            this._isCanceled = true;
+            var parent = this._getTopParent();
+            if (parent) {
+                parent.cancel();
             }
-            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);
+            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;
         };
-        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));
+        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 true;
             }
-            return false;
+            return parent;
         };
-        Cache.instance = {};
-        return Cache;
+        CancelablePromise.prototype._destroy = function () {
+            this._setCanceledCallback = undefined;
+            this._cancelPromise = undefined;
+            this._promise = undefined;
+        };
+        CancelablePromise.CancelError = CancelError;
+        CancelablePromise.TimeoutError = TimeoutError;
+        CancelablePromise.PromiseControl = PromiseControl;
+        return CancelablePromise;
     }());
+    Object.setPrototypeOf(CancelablePromise$1.prototype, Promise.prototype);
 
     /**
-     * Caching for asynchronous functions
+     * A promise you can stop
      *
      * @packageDocumentation
-     * @module cache
-     */
-    var Cache = Cache$1;
-
-    /**
-     * Thrown when...
+     * @module cancelable-promise
      */
-    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));
+    var CancelablePromise = CancelablePromise$1;
 
     /**
      * Thrown when...
@@ -1246,195 +1231,6 @@ var NgwConnector = (function () {
         return NgwError;
     }(Error));
 
-    function isObject(val) {
-        return Object.prototype.toString.call(val) === '[object Object]';
-    }
-
-    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
-    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) {
-        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);
-            });
-        });
-    }
-
     /**
      * Thrown when ...
      */
@@ -1444,51 +1240,18 @@ var NgwConnector = (function () {
             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);
+            Object.setPrototypeOf(_this, ResourceNotFoundError.prototype);
+            return _this;
         }
+        return ResourceNotFoundError;
+    }(NgwError));
+
+    function isObject(val) {
+        return Object.prototype.toString.call(val) === '[object Object]';
+    }
+
+    function resourceCompare(res1, res2) {
+        return objectDeepEqual(res1, res2);
     }
 
     var exclude = ['description'];
@@ -1526,10 +1289,6 @@ var NgwConnector = (function () {
         return query;
     }
 
-    function resourceCompare(res1, res2) {
-        return objectDeepEqual(res1, res2);
-    }
-
     var ResourcesControl = /** @class */ (function () {
         function ResourcesControl(connector) {
             this.connector = connector;
@@ -1800,6 +1559,247 @@ var NgwConnector = (function () {
         return ResourcesControl;
     }());
 
+    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);
+        }
+    }
+
+    /**
+     * 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));
+
+    // 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) {
+        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);
+            });
+        });
+    }
+
+    /**
+     * 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));
+
+    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);
+        };
+    }
+
     var ID = 0;
     var NgwConnector$1 = /** @class */ (function () {
         function NgwConnector(options) {