@nextgis/ngw-connector 1.18.21 → 1.19.0

package/lib/ngw-connector.esm-browser.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 events = {exports: {}};
 
 var R = typeof Reflect === 'object' ? Reflect : null;
@@ -475,628 +475,615 @@ function eventTargetAgnosticAddListener(emitter, name, listener, flags) {
   }
 }
 
-class CancelError extends Error {
-    constructor() {
-        super();
-        this.name = 'CancelError';
-        Object.setPrototypeOf(this, CancelError.prototype);
-    }
+/**
+ * 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);
 }
 
-class PromiseControl {
-    constructor(options = {}) {
-        this.options = options;
-        this._promises = new Map();
-    }
-    get isLoaded() {
-        return this._promises.size > 0;
+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('');
     }
-    remove(promise) {
-        if (this._promises.has(promise)) {
-            this._promises.delete(promise);
-            this._onStop();
-        }
+    else if (a instanceof Date) {
+        if (!(b instanceof Date))
+            return false;
+        return '' + a === '' + b;
     }
-    get(promise) {
-        return this._promises.get(promise);
+    else if (a instanceof Function) {
+        if (!(b instanceof Function))
+            return false;
+        //ignore functions, or check them regardless?
     }
-    add(promise, name) {
-        const key = name ? name : promise;
-        const exist = this._promises.get(key);
-        if (this.options.onStart && !this.isLoaded) {
-            this.options.onStart();
+    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(() => {
-            this.remove(key);
-        });
-        return promise;
     }
-    abort() {
-        if (this.isLoaded) {
-            this._promises.forEach((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) {
+    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;
         }
     }
-    waitFunc(func, name = '') {
-        name = name || func.name;
-        const exist = this.get(name);
-        if (exist) {
-            return exist;
+    return true;
+}
+
+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]);
         }
-        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();
+        else if (obj[key] !== undefined) {
+            newObj[key] = obj[key];
         }
-    }
+    });
+    return newObj;
 }
 
-class TimeoutError extends Error {
-    constructor() {
-        super();
-        this.name = 'TimeoutError';
-        Object.setPrototypeOf(this, TimeoutError.prototype);
-    }
+function fixUrlStr(url) {
+    // remove double slash
+    return url.replace(/([^:]\/)\/+/g, '$1');
 }
 
-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 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
  * ```
  */
-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);
-            }));
+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];
         }
-        this._promise = Promise.race(promises);
+        Cache$1.instance[namespace] = this;
+        return this;
     }
-    static createControl(opt) {
-        return new PromiseControl(opt);
+    clean() {
+        this.cache.length = 0;
     }
-    static resolve(value) {
-        return new CancelablePromise$1((resolve) => resolve(value));
+    all() {
+        return this.cache;
     }
-    static reject(value) {
-        return new CancelablePromise$1((resolve, reject) => 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'
+     * })
+     *
+     * ```
+     */
+    addFull(key, valueToSet, props) {
+        return this.add(key, valueToSet, props, true);
     }
-    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();
-                    }
+    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;
             }
-            throw er;
-        });
-    }
-    attach(p) {
-        if (this._isCanceled) {
-            p.cancel();
+            return value;
         }
         else {
-            this._children.push(p);
+            return exist.value;
         }
     }
-    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());
+    match(key, props) {
+        const cacheRecord = this._find(key, props);
+        if (cacheRecord) {
+            return cacheRecord.value;
         }
-        return this.then(undefined, onrejected);
     }
-    finally(onfinally) {
-        if (this._promise) {
-            return this._promise.finally(onfinally);
-        }
-        if (this._isCanceled) {
-            return Promise.reject(new CancelError());
+    matchAll(key, props) {
+        if (key) {
+            return this.cache
+                .filter((x) => this._filter(x, key, props))
+                .map((x) => x.value);
         }
-        return Promise.reject(onfinally);
+        return this.cache.map((x) => x.value);
     }
-    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();
+    delete(keyOrItem, props) {
+        let exist = [];
+        if (typeof keyOrItem === 'string') {
+            exist = this.cache.filter((x) => this._filter(x, keyOrItem, props));
         }
-        if (this._children) {
-            this._children.forEach((x) => x.cancel());
+        else {
+            exist.push(keyOrItem);
         }
-        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();
-            }
+        for (const e of exist) {
+            const index = this.cache.indexOf(e);
+            this.cache.splice(index, 1);
         }
-        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;
+    _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 parent;
-    }
-    _destroy() {
-        this._setCanceledCallback = undefined;
-        this._cancelPromise = undefined;
-        this._promise = undefined;
+        return false;
     }
 }
-CancelablePromise$1.CancelError = CancelError;
-CancelablePromise$1.TimeoutError = TimeoutError;
-CancelablePromise$1.PromiseControl = PromiseControl;
-Object.setPrototypeOf(CancelablePromise$1.prototype, Promise.prototype);
+Cache$1.instance = {};
 
 /**
- * A promise you can stop
+ * Caching for asynchronous functions
  *
  * @packageDocumentation
- * @module cancelable-promise
+ * @module cache
  */
-var CancelablePromise = CancelablePromise$1;
+var Cache = Cache$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);
+class CancelError extends Error {
+    constructor() {
+        super();
+        this.name = 'CancelError';
+        Object.setPrototypeOf(this, CancelError.prototype);
+    }
 }
 
-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('');
+class PromiseControl {
+    constructor(options = {}) {
+        this.options = options;
+        this._promises = new Map();
     }
-    else if (a instanceof Date) {
-        if (!(b instanceof Date))
-            return false;
-        return '' + a === '' + b;
+    get isLoaded() {
+        return this._promises.size > 0;
     }
-    else if (a instanceof Function) {
-        if (!(b instanceof Function))
-            return false;
-        //ignore functions, or check them regardless?
+    remove(promise) {
+        if (this._promises.has(promise)) {
+            this._promises.delete(promise);
+            this._onStop();
+        }
     }
-    else if (a instanceof Object) {
-        if (!(b instanceof Object))
-            return false;
-        if (a === o) {
-            return b === p;
+    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();
         }
-        else {
-            return objectDeepEqual(a, b);
+        if (exist) {
+            return exist;
         }
+        this._promises.set(key, promise);
+        promise.finally(() => {
+            this.remove(key);
+        });
+        return promise;
     }
-    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;
+    abort() {
+        if (this.isLoaded) {
+            this._promises.forEach((x) => {
+                if (x.cancel) {
+                    x.cancel();
+                }
+            });
+            this._promises.clear();
+            this._onStop();
         }
     }
-    return true;
-}
-
-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]);
+    waitFunc(func, name = '') {
+        name = name || func.name;
+        const exist = this.get(name);
+        if (exist) {
+            return exist;
         }
-        else if (obj[key] !== undefined) {
-            newObj[key] = obj[key];
+        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();
         }
-    });
-    return newObj;
+    }
 }
 
-function fixUrlStr(url) {
-    // remove double slash
-    return url.replace(/([^:]\/)\/+/g, '$1');
+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
- * 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();
  * ```
  */
-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);
+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();
                         }
-                        return x;
-                    });
+                        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();
+                    }
                 }
-                return value;
             }
-            return value;
+            throw er;
+        });
+    }
+    attach(p) {
+        if (this._isCanceled) {
+            p.cancel();
         }
         else {
-            return exist.value;
+            this._children.push(p);
         }
     }
-    match(key, props) {
-        const cacheRecord = this._find(key, props);
-        if (cacheRecord) {
-            return cacheRecord.value;
+    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);
     }
-    matchAll(key, props) {
-        if (key) {
-            return this.cache
-                .filter((x) => this._filter(x, key, props))
-                .map((x) => x.value);
+    finally(onfinally) {
+        if (this._promise) {
+            return this._promise.finally(onfinally);
         }
-        return this.cache.map((x) => x.value);
+        if (this._isCanceled) {
+            return Promise.reject(new CancelError());
+        }
+        return Promise.reject(onfinally);
     }
-    delete(keyOrItem, props) {
-        let exist = [];
-        if (typeof keyOrItem === 'string') {
-            exist = this.cache.filter((x) => this._filter(x, keyOrItem, props));
+    cancel() {
+        // 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;
+        const parent = this._getTopParent();
+        if (parent) {
+            parent.cancel();
         }
-        for (const e of exist) {
-            const index = this.cache.indexOf(e);
-            this.cache.splice(index, 1);
+        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;
     }
-    _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));
+    _getTopParent() {
+        let parent = this._parentPromise;
+        let hasParent = !!parent;
+        while (hasParent) {
+            if (parent && parent._parentPromise) {
+                parent = parent._parentPromise;
+                hasParent = !!parent;
+            }
+            else {
+                hasParent = false;
             }
-            return true;
         }
-        return false;
+        return parent;
+    }
+    _destroy() {
+        this._setCanceledCallback = undefined;
+        this._cancelPromise = undefined;
+        this._promise = undefined;
     }
 }
-Cache$1.instance = {};
+CancelablePromise$1.CancelError = CancelError;
+CancelablePromise$1.TimeoutError = TimeoutError;
+CancelablePromise$1.PromiseControl = PromiseControl;
+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
  */
-class NetworkError extends Error {
-    constructor(url) {
-        super();
-        this.name = 'NetworkError';
-        Object.setPrototypeOf(this, NetworkError.prototype);
-        this.message = `Unable to request ${url}.
-    Possibly invalid NGW URL entered or CORS not configured to get request from ${location.origin}`; // /control-panel/cors
-    }
-}
+var CancelablePromise = CancelablePromise$1;
 
 /**
  * Thrown when...
@@ -1109,244 +1096,27 @@ class NgwError extends Error {
         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);
-    };
-}
-
-// 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;
-    });
-}
-
-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);
+
+/**
+ * Thrown when ...
+ */
+class ResourceNotFoundError extends NgwError {
+    constructor(obj) {
+        super(obj);
+        this.name = 'ResourceNotFoundError';
+        this.exception = 'nextgisweb.resource.exception.ResourceNotFound';
+        Object.setPrototypeOf(this, ResourceNotFoundError.prototype);
     }
 }
 
+function isObject(val) {
+    return Object.prototype.toString.call(val) === '[object Object]';
+}
+
+function resourceCompare(res1, res2) {
+    return objectDeepEqual(res1, res2);
+}
+
 const exclude = ['description'];
 /**
  * @remarks
@@ -1380,10 +1150,6 @@ function resourceToQuery(resource, prefix = '') {
     return query;
 }
 
-function resourceCompare(res1, res2) {
-    return objectDeepEqual(res1, res2);
-}
-
 class ResourcesControl {
     constructor(connector) {
         this.connector = connector;
@@ -1624,6 +1390,240 @@ class ResourcesControl {
     }
 }
 
+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);
+    }
+}
+
+/**
+ * Thrown when ...
+ */
+class InsufficientPermissionsError extends NgwError {
+    constructor(obj) {
+        super(obj);
+        this.name = 'InsufficientPermissionsError';
+        this.exception = 'nextgisweb.core.exception.InsufficientPermissions';
+        Object.setPrototypeOf(this, InsufficientPermissionsError.prototype);
+    }
+}
+
+// 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;
+    });
+}
+
+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 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
+    }
+}
+
+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);
+    };
+}
+
 let ID = 0;
 class NgwConnector$1 {
     constructor(options) {