@nextgis/geocoder 3.0.0-alpha.0 → 3.0.0-alpha.12

package/lib/geocoder.global.js

@@ -1,4 +1,4 @@
-/** Bundle of @nextgis/geocoder; version: 3.0.0-alpha.0; author: NextGIS */
+/** Bundle of @nextgis/geocoder; version: 3.0.0-alpha.9; author: NextGIS */
 var Geocoder = (function (exports) {
   'use strict';
 
@@ -107,28 +107,28 @@ var Geocoder = (function (exports) {
     }
   }
 
-  var __defProp$d = Object.defineProperty;
-  var __defProps$3 = Object.defineProperties;
-  var __getOwnPropDescs$3 = Object.getOwnPropertyDescriptors;
-  var __getOwnPropSymbols$6 = Object.getOwnPropertySymbols;
-  var __hasOwnProp$6 = Object.prototype.hasOwnProperty;
-  var __propIsEnum$6 = Object.prototype.propertyIsEnumerable;
+  var __defProp$i = Object.defineProperty;
+  var __defProps$5 = Object.defineProperties;
+  var __getOwnPropDescs$5 = Object.getOwnPropertyDescriptors;
+  var __getOwnPropSymbols$8 = Object.getOwnPropertySymbols;
+  var __hasOwnProp$8 = Object.prototype.hasOwnProperty;
+  var __propIsEnum$8 = Object.prototype.propertyIsEnumerable;
   var __knownSymbol$2 = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
-  var __defNormalProp$d = (obj, key, value) => key in obj ? __defProp$d(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-  var __spreadValues$6 = (a, b) => {
+  var __defNormalProp$i = (obj, key, value) => key in obj ? __defProp$i(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+  var __spreadValues$8 = (a, b) => {
     for (var prop in b || (b = {}))
-      if (__hasOwnProp$6.call(b, prop))
-        __defNormalProp$d(a, prop, b[prop]);
-    if (__getOwnPropSymbols$6)
-      for (var prop of __getOwnPropSymbols$6(b)) {
-        if (__propIsEnum$6.call(b, prop))
-          __defNormalProp$d(a, prop, b[prop]);
+      if (__hasOwnProp$8.call(b, prop))
+        __defNormalProp$i(a, prop, b[prop]);
+    if (__getOwnPropSymbols$8)
+      for (var prop of __getOwnPropSymbols$8(b)) {
+        if (__propIsEnum$8.call(b, prop))
+          __defNormalProp$i(a, prop, b[prop]);
       }
     return a;
   };
-  var __spreadProps$3 = (a, b) => __defProps$3(a, __getOwnPropDescs$3(b));
-  var __publicField$a = (obj, key, value) => __defNormalProp$d(obj, key + "" , value);
-  var __async$5 = (__this, __arguments, generator) => {
+  var __spreadProps$5 = (a, b) => __defProps$5(a, __getOwnPropDescs$5(b));
+  var __publicField$d = (obj, key, value) => __defNormalProp$i(obj, key + "" , value);
+  var __async$7 = (__this, __arguments, generator) => {
     return new Promise((resolve, reject) => {
       var fulfilled = (value) => {
         try {
@@ -168,7 +168,7 @@ var Geocoder = (function (exports) {
   class Geocoder extends BaseGeocoder {
     constructor(options) {
       super(options);
-      __publicField$a(this, "providers", []);
+      __publicField$d(this, "providers", []);
       if (options && options.providers) {
         this.providers = options.providers;
       }
@@ -192,7 +192,7 @@ var Geocoder = (function (exports) {
               for (var iter = __forAwait(results), more, temp, error; more = !(temp = yield new __await$2(iter.next())).done; more = false) {
                 const r = temp.value;
                 allProvidersFailed = false;
-                yield __spreadProps$3(__spreadValues$6({}, r), { provider, _id: ID$1++ });
+                yield __spreadProps$5(__spreadValues$8({}, r), { provider, _id: ID$1++ });
               }
             } catch (temp) {
               error = [temp];
@@ -206,7 +206,7 @@ var Geocoder = (function (exports) {
             }
           } catch (err) {
             const er = err;
-            if (er.name !== "CancelError") {
+            if (er.name !== "AbortError") {
               errors.push(er);
             }
           }
@@ -235,7 +235,7 @@ var Geocoder = (function (exports) {
             try {
               for (var iter = __forAwait(results), more, temp, error; more = !(temp = yield new __await$2(iter.next())).done; more = false) {
                 const r = temp.value;
-                yield __spreadProps$3(__spreadValues$6({}, r), { provider, _id: ID$1++ });
+                yield __spreadProps$5(__spreadValues$8({}, r), { provider, _id: ID$1++ });
               }
             } catch (temp) {
               error = [temp];
@@ -259,7 +259,7 @@ var Geocoder = (function (exports) {
      * @returns A promise that resolves to the first reverse geocoding result, or undefined if no results are found.
      */
     reverseGeocodeFirstResult(coordinates) {
-      return __async$5(this, null, function* () {
+      return __async$7(this, null, function* () {
         for (const provider of this.providers) {
           if (typeof provider.reverse === "function") {
             try {
@@ -288,9 +288,9 @@ var Geocoder = (function (exports) {
     }
   }
 
-  var __defProp$c = Object.defineProperty;
-  var __defNormalProp$c = (obj, key, value) => key in obj ? __defProp$c(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-  var __publicField$9 = (obj, key, value) => __defNormalProp$c(obj, typeof key !== "symbol" ? key + "" : key, value);
+  var __defProp$h = Object.defineProperty;
+  var __defNormalProp$h = (obj, key, value) => key in obj ? __defProp$h(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+  var __publicField$c = (obj, key, value) => __defNormalProp$h(obj, typeof key !== "symbol" ? key + "" : key, value);
   class BaseProvider extends BaseGeocoder {
     constructor() {
       super(...arguments);
@@ -298,12 +298,12 @@ var Geocoder = (function (exports) {
        * URL endpoint for the search service.
        * This is where queries will be sent to obtain search results.
        */
-      __publicField$9(this, "searchUrl");
+      __publicField$c(this, "searchUrl");
       /**
        * Label to represent the provider.
        * Useful for user interfaces to display the source of search results.
        */
-      __publicField$9(this, "label");
+      __publicField$c(this, "label");
     }
   }
 
@@ -337,7 +337,7 @@ var Geocoder = (function (exports) {
     this.domain = null;
     if (EventEmitter.usingDomains) {
       // if there is an active domain, then attach to it.
-      if (domain.active ) ;
+      if (domain.active) ;
     }
 
     if (!this._events || this._events === Object.getPrototypeOf(this)._events) {
@@ -779,12 +779,12 @@ var Geocoder = (function (exports) {
     return ret;
   }
 
-  var __defProp$b = Object.defineProperty;
-  var __defNormalProp$b = (obj, key, value) => key in obj ? __defProp$b(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-  var __publicField$8 = (obj, key, value) => __defNormalProp$b(obj, typeof key !== "symbol" ? key + "" : key, value);
+  var __defProp$g = Object.defineProperty;
+  var __defNormalProp$g = (obj, key, value) => key in obj ? __defProp$g(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+  var __publicField$b = (obj, key, value) => __defNormalProp$g(obj, typeof key !== "symbol" ? key + "" : key, value);
   const _Cache = class _Cache {
     constructor(options = {}) {
-      __publicField$8(this, "cache", []);
+      __publicField$b(this, "cache", []);
       var _a;
       const namespace = (_a = options.namespace) != null ? _a : "default";
       if (_Cache.instance[namespace]) {
@@ -820,10 +820,23 @@ var Geocoder = (function (exports) {
      * });
      * ```
      */
-    addFull(key, valueToSet, props) {
-      return this.add(key, valueToSet, props, true);
-    }
-    add(key, valueToSet, props, onlyFull) {
+    addFull(key, valueToSet, propsOrOptions, expirationTime) {
+      if (typeof propsOrOptions === "object" && "valueToSet" in propsOrOptions) {
+        propsOrOptions.onlyFull = true;
+      }
+      return this.add(key, valueToSet, propsOrOptions, true, expirationTime);
+    }
+    add(key, valueToSet, propsOrOptions, onlyFull, expirationTime) {
+      let opt;
+      let props;
+      if (typeof propsOrOptions === "object" && "valueToSet" in propsOrOptions) {
+        opt = propsOrOptions;
+        onlyFull = opt.onlyFull;
+        expirationTime = opt.expirationTime;
+        props = opt.props;
+      } else {
+        props = propsOrOptions;
+      }
       const exist = this._find(key, props);
       if (!exist) {
         let value;
@@ -833,10 +846,12 @@ var Geocoder = (function (exports) {
           value = valueToSet;
         }
         const nonEmptyProps = props && JSON.parse(JSON.stringify(objectRemoveEmpty(props)));
+        expirationTime = expirationTime ? Date.now() + expirationTime : void 0;
         const cacheItem = {
           key,
           value,
-          props: nonEmptyProps
+          props: nonEmptyProps,
+          expirationTime
         };
         if (onlyFull && !full(value)) {
           return value;
@@ -863,9 +878,19 @@ var Geocoder = (function (exports) {
     }
     match(key, props) {
       const cacheRecord = this._find(key, props);
+      if (cacheRecord && cacheRecord.expirationTime && Date.now() > cacheRecord.expirationTime) {
+        this.delete(cacheRecord);
+        return void 0;
+      }
       return cacheRecord == null ? void 0 : cacheRecord.value;
     }
     matchAll(key, props) {
+      const now = Date.now();
+      this.cache.forEach((item) => {
+        if (item.expirationTime && now > item.expirationTime) {
+          this.delete(item);
+        }
+      });
       if (key) {
         return this.cache.filter((x) => this._filter(x, key, props)).map((x) => x.value);
       }
@@ -890,31 +915,159 @@ var Geocoder = (function (exports) {
       return objectDeepEqual(itemProps || {}, objectRemoveEmpty(props));
     }
   };
-  __publicField$8(_Cache, "instance", {});
+  __publicField$b(_Cache, "instance", {});
   let Cache = _Cache;
 
-  var __defProp$a = Object.defineProperty;
-  var __defNormalProp$a = (obj, key, value) => key in obj ? __defProp$a(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-  var __publicField$7 = (obj, key, value) => __defNormalProp$a(obj, typeof key !== "symbol" ? key + "" : key, value);
+  var pkg = {
+  	name: "@nextgis/ngw-connector",
+  	version: "3.0.0-alpha.8",
+  	_priority: 12,
+  	description: "A lightweight HTTP client optimized for use with NextGIS Web API",
+  	main: "index.js",
+  	module: "lib/ngw-connector.esm-bundler.js",
+  	unpkg: "lib/ngw-connector.global.prod.js",
+  	jsdelivr: "lib/ngw-connector.global.prod.js",
+  	types: "lib/index.d.ts",
+  	dependencies: {
+  		"@nextgis/cache": "^3.0.0-alpha.7",
+  		"@nextgis/cancelable-promise": "^3.0.0-alpha.5",
+  		"@nextgis/utils": "^3.0.0-alpha.5",
+  		"@types/events": "^3.0.0",
+  		events: "*",
+  		"form-data": "^4.0.0"
+  	},
+  	devDependencies: {
+  		"@nextgis/build-tools": "^3.0.0-alpha.5"
+  	},
+  	scripts: {
+  		clean: "rimraf ./lib",
+  		dev: "node ../build-tools/lib/build.js",
+  		prod: "npm run dev -- --release",
+  		lint: "eslint ./src/**/*.ts --fix --c ../../.eslintrc",
+  		watch: "npm run dev -- --watch",
+  		"gen:types": "node ./scripts/generator"
+  	},
+  	buildOptions: {
+  		name: "NgwConnector",
+  		formats: [
+  			"esm-bundler",
+  			"esm-browser",
+  			"cjs",
+  			"global"
+  		]
+  	},
+  	keywords: [
+  		"NextGIS",
+  		"MAP"
+  	],
+  	author: "NextGIS",
+  	files: [
+  		"index.js",
+  		"lib"
+  	],
+  	license: "MIT",
+  	homepage: "https://github.com/nextgis/nextgis_frontend/tree/master/packages/ngw-connector#readme",
+  	repository: {
+  		type: "git",
+  		url: "git://github.com/nextgis/nextgis_frontend.git"
+  	},
+  	engines: {
+  		node: ">=18.20.4"
+  	},
+  	gitHead: "edc68033f914f6c95c4125b9738bba6d36e990b4"
+  };
+
+  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 {
+          return true;
+        }
+      }
+    });
+  }
+  function removeConnector(connector) {
+    const index = CONNECTORS.indexOf(connector);
+    if (index !== -1) {
+      CONNECTORS.splice(index, 1);
+    }
+  }
+
+  class AbortError extends Error {
+    constructor(message = "AbortError") {
+      super(message);
+      this.name = "AbortError";
+    }
+  }
+
+  var __defProp$f = Object.defineProperty;
+  var __defNormalProp$f = (obj, key, value) => key in obj ? __defProp$f(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+  var __publicField$a = (obj, key, value) => __defNormalProp$f(obj, typeof key !== "symbol" ? key + "" : key, value);
   class NgwError extends Error {
     constructor(er) {
       super();
-      __publicField$7(this, "name", "NgwError");
-      __publicField$7(this, "title");
-      __publicField$7(this, "message");
-      __publicField$7(this, "detail");
-      __publicField$7(this, "exception");
-      __publicField$7(this, "status_code");
-      __publicField$7(this, "data");
-      __publicField$7(this, "guru_meditation");
+      __publicField$a(this, "name", "NgwError");
+      __publicField$a(this, "title");
+      __publicField$a(this, "message");
+      __publicField$a(this, "detail");
+      __publicField$a(this, "exception");
+      __publicField$a(this, "status_code");
+      __publicField$a(this, "data");
+      __publicField$a(this, "guru_meditation");
       Object.assign(this, er);
       Object.setPrototypeOf(this, NgwError.prototype);
     }
   }
 
-  var __defProp$9 = Object.defineProperty;
-  var __defNormalProp$9 = (obj, key, value) => key in obj ? __defProp$9(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-  var __publicField$6 = (obj, key, value) => __defNormalProp$9(obj, typeof key !== "symbol" ? key + "" : key, value);
+  var __defProp$e = Object.defineProperty;
+  var __defNormalProp$e = (obj, key, value) => key in obj ? __defProp$e(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+  var __publicField$9 = (obj, key, value) => __defNormalProp$e(obj, typeof key !== "symbol" ? key + "" : key, value);
+  class InsufficientPermissionsError extends NgwError {
+    constructor(obj) {
+      super(obj);
+      __publicField$9(this, "name", "InsufficientPermissionsError");
+      __publicField$9(this, "exception", "nextgisweb.core.exception.InsufficientPermissions");
+      Object.setPrototypeOf(this, InsufficientPermissionsError.prototype);
+    }
+  }
+
+  var __defProp$d = Object.defineProperty;
+  var __defNormalProp$d = (obj, key, value) => key in obj ? __defProp$d(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+  var __publicField$8 = (obj, key, value) => __defNormalProp$d(obj, key + "" , value);
+  class NetworkError extends Error {
+    constructor(url) {
+      super();
+      __publicField$8(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}`;
+    }
+  }
+
+  var __defProp$c = Object.defineProperty;
+  var __defNormalProp$c = (obj, key, value) => key in obj ? __defProp$c(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+  var __publicField$7 = (obj, key, value) => __defNormalProp$c(obj, typeof key !== "symbol" ? key + "" : key, value);
+  let NetworksResponseError$1 = class NetworksResponseError extends NgwError {
+    constructor(obj) {
+      super(obj);
+      __publicField$7(this, "message", "There is no response from the server or problem connecting to server.");
+      __publicField$7(this, "title", "Network error");
+      __publicField$7(this, "detail", "Check network connectivity and try again later.");
+      Object.setPrototypeOf(this, NetworksResponseError.prototype);
+    }
+  };
+
+  var __defProp$b = Object.defineProperty;
+  var __defNormalProp$b = (obj, key, value) => key in obj ? __defProp$b(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+  var __publicField$6 = (obj, key, value) => __defNormalProp$b(obj, typeof key !== "symbol" ? key + "" : key, value);
   class ResourceNotFoundError extends NgwError {
     constructor(obj) {
       super(obj);
@@ -924,53 +1077,143 @@ var Geocoder = (function (exports) {
     }
   }
 
-  function isObject(val) {
-    return Object.prototype.toString.call(val) === "[object Object]";
+  function isError(error) {
+    if (isObject$1(error)) {
+      return error.status_code && error.exception && error.title;
+    }
+    return false;
   }
 
-  function resourceCompare(res1, res2) {
-    return objectDeepEqual(res1, res2);
+  function extractError(error) {
+    if (isObject$1(error)) {
+      if (error.name && error.message && error.title) {
+        return {
+          title: error.title,
+          message: error.message,
+          detail: error.detail || null,
+          data: error.data && error.data.data ? error.data.data : null
+        };
+      } else if (error.exception) {
+        if (error.status === void 0 || error.status === 0 || error.data === void 0) {
+          return new NetworksResponseError$1({
+            title: error.title,
+            status_code: error.status_code,
+            exception: error.exception
+          });
+        }
+      }
+      return {
+        title: typeof error.title === "string" ? error.title : "Unexpected error",
+        message: typeof error.message === "string" ? error.message : "Something went wrong."
+      };
+    }
   }
 
-  const exclude = ["description"];
-  function resourceToQuery(resource, prefix = "") {
-    prefix = prefix ? prefix + "__" : "";
-    const query = {};
-    for (const [key, value] of Object.entries(resource)) {
-      if (exclude.indexOf(key) === -1) {
-        if (isObject(value)) {
-          if (key === "owner_user") {
-            const children = resourceToQuery(value, key);
-            Object.assign(query, children);
-          } else if (key === "parent" && "id" in value) {
-            query.parent_id = value.id;
-          }
-        } else if (defined(value)) {
-          query[prefix + key] = value;
-        }
+  var errors = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    AbortError: AbortError,
+    InsufficientPermissionsError: InsufficientPermissionsError,
+    NetworkError: NetworkError,
+    NetworksResponseError: NetworksResponseError$1,
+    NgwError: NgwError,
+    ResourceNotFoundError: ResourceNotFoundError,
+    extractError: extractError,
+    isError: isError
+  });
+
+  var __defProp$a = Object.defineProperty;
+  var __defNormalProp$a = (obj, key, value) => key in obj ? __defProp$a(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+  var __publicField$5 = (obj, key, value) => __defNormalProp$a(obj, typeof key !== "symbol" ? key + "" : key, value);
+  class BaseAPIError extends Error {
+    constructor(message) {
+      super(message || "Something went wrong.");
+      __publicField$5(this, "title");
+      this.name = "BaseAPIError";
+      this.title = "Unknown API error";
+      if (Error.captureStackTrace) {
+        Error.captureStackTrace(this, BaseAPIError);
       }
     }
-    return query;
+  }
+  class NetworksResponseError extends BaseAPIError {
+    // prettier-ignore
+    constructor(message) {
+      super(message || "There is no response from the server or problem connecting to server.");
+      __publicField$5(this, "detail");
+      this.title = "Network error";
+      this.detail = "Check network connectivity and try again later.";
+    }
+  }
+  class InvalidResponseError extends BaseAPIError {
+    constructor(message) {
+      super(message || "Something went wrong.");
+      this.title = "Unexpected server response";
+    }
+  }
+  class ServerResponseError extends BaseAPIError {
+    constructor(data) {
+      super(data.message);
+      __publicField$5(this, "detail");
+      __publicField$5(this, "data");
+      this.title = data.title || this.title;
+      this.detail = data.detail || null;
+      this.data = data;
+    }
+  }
+  class LunkwillError extends Error {
+    // prettier-ignore
+    constructor(message, data = {}) {
+      super(message || "Unexpected error while processing long-running request.");
+      __publicField$5(this, "title");
+      __publicField$5(this, "data");
+      this.name = "LunkwillError";
+      this.title = "Long-running request error";
+      this.data = data;
+      if (Error.captureStackTrace) {
+        Error.captureStackTrace(this, LunkwillError);
+      }
+    }
+  }
+  class LunkwillRequestCancelled extends LunkwillError {
+    constructor(data) {
+      super("Long-running request was cancelled.", data);
+    }
+  }
+  class LunkwillRequestFailed extends LunkwillError {
+    constructor(data) {
+      super(void 0, data);
+    }
   }
 
-  var __defProp$8 = Object.defineProperty;
-  var __getOwnPropSymbols$5 = Object.getOwnPropertySymbols;
-  var __hasOwnProp$5 = Object.prototype.hasOwnProperty;
-  var __propIsEnum$5 = Object.prototype.propertyIsEnumerable;
-  var __defNormalProp$8 = (obj, key, value) => key in obj ? __defProp$8(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-  var __spreadValues$5 = (a, b) => {
+  var __defProp$9 = Object.defineProperty;
+  var __getOwnPropSymbols$7 = Object.getOwnPropertySymbols;
+  var __hasOwnProp$7 = Object.prototype.hasOwnProperty;
+  var __propIsEnum$7 = Object.prototype.propertyIsEnumerable;
+  var __defNormalProp$9 = (obj, key, value) => key in obj ? __defProp$9(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+  var __spreadValues$7 = (a, b) => {
     for (var prop in b || (b = {}))
-      if (__hasOwnProp$5.call(b, prop))
-        __defNormalProp$8(a, prop, b[prop]);
-    if (__getOwnPropSymbols$5)
-      for (var prop of __getOwnPropSymbols$5(b)) {
-        if (__propIsEnum$5.call(b, prop))
-          __defNormalProp$8(a, prop, b[prop]);
+      if (__hasOwnProp$7.call(b, prop))
+        __defNormalProp$9(a, prop, b[prop]);
+    if (__getOwnPropSymbols$7)
+      for (var prop of __getOwnPropSymbols$7(b)) {
+        if (__propIsEnum$7.call(b, prop))
+          __defNormalProp$9(a, prop, b[prop]);
       }
     return a;
   };
-  var __publicField$5 = (obj, key, value) => __defNormalProp$8(obj, typeof key !== "symbol" ? key + "" : key, value);
-  var __async$4 = (__this, __arguments, generator) => {
+  var __objRest$2 = (source, exclude) => {
+    var target = {};
+    for (var prop in source)
+      if (__hasOwnProp$7.call(source, prop) && exclude.indexOf(prop) < 0)
+        target[prop] = source[prop];
+    if (source != null && __getOwnPropSymbols$7)
+      for (var prop of __getOwnPropSymbols$7(source)) {
+        if (exclude.indexOf(prop) < 0 && __propIsEnum$7.call(source, prop))
+          target[prop] = source[prop];
+      }
+    return target;
+  };
+  var __async$6 = (__this, __arguments, generator) => {
     return new Promise((resolve, reject) => {
       var fulfilled = (value) => {
         try {
@@ -990,94 +1233,935 @@ var Geocoder = (function (exports) {
       step((generator = generator.apply(__this, __arguments)).next());
     });
   };
-  class ResourcesControl {
-    constructor({
-      connector,
-      cacheId
-    }) {
-      __publicField$5(this, "cache");
-      __publicField$5(this, "connector");
-      this.connector = connector;
-      this.cache = new Cache({ namespace: cacheId });
-    }
-    // -------------------------------------------------------------------------
-    // Resource Methods
-    // -------------------------------------------------------------------------
-    /**
-     * Receive resource from NGW by id, keyname or search-object parameter.
-     * @param resource - Resource id, keyname or search-object
-     *
-     * @remarks
-     * Fetching resource would be cached to speed up next call
-     */
-    getOne(resource, requestOptions) {
-      const opt = __spreadValues$5({}, requestOptions);
-      if (typeof resource === "string") ; else if (typeof resource === "number") ; else if (isObject(resource)) {
-        if (resource.id !== void 0) {
-          resource.id;
-        } else {
-          if (resource.keyname) {
-            resource.keyname;
-          }
-          if (resource.display_name) {
-            resource.display_name;
-          }
+  function lunkwillCheckResponse(lwResp) {
+    const ct = lwResp.headers.get("content-type");
+    return ct !== void 0 && ct !== null && ct.includes("application/vnd.lunkwill.request-summary+json");
+  }
+  function responseJson(response) {
+    return __async$6(this, null, function* () {
+      try {
+        return response.json();
+      } catch (e) {
+        throw new Error();
+      }
+    });
+  }
+  function lunkwillResponseUrl(lwResp) {
+    return __async$6(this, null, function* () {
+      const lwData = yield responseJson(lwResp);
+      let delay = lwData.delay_ms;
+      const retry = lwData.retry_ms !== void 0 ? lwData.retry_ms : 2e3;
+      const sum = `/api/lunkwill/${lwData.id}/summary`;
+      const res = `/api/lunkwill/${lwData.id}/response`;
+      const sleep = (msec) => new Promise((resolve) => setTimeout(resolve, msec));
+      let failed = false;
+      let ready = false;
+      while (!ready) {
+        yield sleep(failed ? retry : delay);
+        failed = false;
+        let lwResp2;
+        let lwData2;
+        try {
+          lwResp2 = yield fetch(sum, { credentials: "same-origin" });
+          lwData2 = yield lwResp2.json();
+        } catch (e) {
+          failed = true;
+          continue;
+        }
+        switch (lwData2.status) {
+          case void 0:
+            throw new LunkwillError(void 0, lwData2);
+          case "ready":
+            ready = true;
+            break;
+          case "cancelled":
+            throw new LunkwillRequestCancelled(lwData2);
+          case "failed":
+            throw new LunkwillRequestFailed(lwData2);
+          case "spooled":
+          case "processing":
+          case "buffering":
+            delay = lwData2.delay_ms;
+            break;
+          default:
+            throw new LunkwillError(void 0, lwData2);
         }
       }
-      if (typeof resource === "string") {
-        return this._fetchResourceBy({ keyname: resource }, opt);
-      } else if (typeof resource === "number") {
-        return this._fetchResourceById(resource, opt);
-      } else if (isObject(resource)) {
-        return this._fetchResourceBy(resource, opt);
+      return res;
+    });
+  }
+  function lunkwillFetch(lwRespUrl) {
+    return __async$6(this, null, function* () {
+      try {
+        return yield window.fetch(lwRespUrl, { credentials: "same-origin" });
+      } catch (e) {
+        throw new NetworksResponseError();
       }
-      return Promise.resolve(void 0);
-    }
-    getOneOrFail(resource, requestOptions) {
-      return this.getOne(resource, requestOptions).then((res) => {
-        if (res) {
-          return res;
-        }
-        throw new ResourceNotFoundError();
-      });
-    }
-    /**
-     * A fast way to retrieve resource ID for any resource definition.
-     * @param resource - Any available resource definition
-     *
-     * @remarks
-     * There are situations when exactly the resource id is needed
-     * (for example, to compose the correct request to the api)
-     * then this method will come in handy to facilitate the extraction of the identifier
-     * if the resource is specified through a keyname or other parameters.
-     */
-    getId(resource, requestOptions) {
-      if (typeof resource === "number") {
-        return Promise.resolve(resource);
-      } else if (typeof resource === "string" || isObject(resource)) {
-        return this.getOne(resource, requestOptions).then((res) => {
-          if (res) {
-            return res.resource.id;
+    });
+  }
+  const mediaContentTypes = [
+    "application/pdf",
+    "image/png",
+    "image/jpeg",
+    "image/tiff",
+    "text/csv"
+  ];
+  const mediaContentTypesRegex = new RegExp(mediaContentTypes.join("|"));
+  function isMediaContentType(contentType) {
+    return mediaContentTypesRegex.test(contentType);
+  }
+  function encodeQueryParams(value) {
+    const result = [];
+    for (const [k, v] of Object.entries(value)) {
+      if (typeof v === "string" || typeof v === "number" || typeof v === "boolean") {
+        result.push(`${k}=${encodeURIComponent(v)}`);
+      } else if (Array.isArray(v)) {
+        result.push(`${k}=${v.map(encodeURIComponent).join(",")}`);
+      } else {
+        for (const [sk, sv] of Object.entries(v)) {
+          const ske = `${k}[${encodeURIComponent(sk)}]`;
+          if (typeof sv === "string" || typeof sv === "number" || typeof sv === "boolean") {
+            result.push(`${ske}=${encodeURIComponent(sv)}`);
+          } else if (Array.isArray(sv)) {
+            const sve = sv.map(encodeURIComponent);
+            result.push(`${ske}=${sve.join(",")}`);
           }
-        });
+        }
       }
-      return Promise.resolve(void 0);
     }
-    /**
-     * A fast way to retrieve resource ID for any resource definition.
-     * @param resource - Any available resource definition
-     *
-     * @remarks
-     * Similar with {@link NgwConnector.getResourceId | getResourceId} but rise error if resource is not exist.
-     * To not make one more checks if the resource is definitely exists
-     */
-    getIdOrFail(resource, requestOptions) {
-      return this.getId(resource, requestOptions).then((resp) => {
-        if (resp === void 0) {
-          throw new Error();
-        }
-        return resp;
-      });
+    return result.join("&");
+  }
+  function generateUrl(path, query) {
+    let urlParams = "";
+    if (query !== void 0) {
+      urlParams = "?" + encodeQueryParams(query);
+    }
+    return path + urlParams;
+  }
+  function request(path, options, cacheEngine) {
+    return __async$6(this, null, function* () {
+      var _b;
+      const defaults = {
+        method: "GET",
+        credentials: "same-origin",
+        headers: {}
+      };
+      const _a = __spreadValues$7(__spreadValues$7({}, defaults), options), {
+        withCredentials,
+        responseType,
+        cacheProps,
+        cacheName,
+        lunkwill,
+        cache,
+        query,
+        json
+      } = _a, opt = __objRest$2(_a, [
+        "withCredentials",
+        "responseType",
+        "cacheProps",
+        "cacheName",
+        "lunkwill",
+        "cache",
+        "query",
+        "json"
+      ]);
+      if (withCredentials) {
+        opt.credentials = "include";
+      }
+      let useLunkwill = false;
+      if (lunkwill !== void 0) {
+        lunkwill.toHeaders(opt.headers || {});
+        useLunkwill = true;
+      }
+      const lunkwillReturnUrl = !!opt.lunkwillReturnUrl;
+      delete opt.lunkwillReturnUrl;
+      if (json !== void 0) {
+        opt.body = JSON.stringify(json);
+        const headers = opt.headers || {};
+        headers["Content-Type"] = "application/json";
+        opt.headers = headers;
+      }
+      const url = generateUrl(path, query);
+      const makeRequest = () => __async$6(this, null, function* () {
+        let response;
+        try {
+          response = yield fetch(url, opt);
+        } catch (e) {
+          if (opt.signal && opt.signal.aborted) {
+            throw e;
+          }
+          throw new NetworksResponseError();
+        }
+        if (useLunkwill && lunkwillCheckResponse(response)) {
+          const lwRespUrl = yield lunkwillResponseUrl(response);
+          if (lunkwillReturnUrl) {
+            return lwRespUrl;
+          }
+          response = yield lunkwillFetch(lwRespUrl);
+        }
+        const respCType = response.headers.get("content-type");
+        const respJSON = respCType && (respCType.includes("application/json") || respCType.includes("application/vnd.lunkwill.request-summary+json"));
+        let body;
+        try {
+          const respMedia = respCType && isMediaContentType(respCType);
+          if (responseType === "blob" || respMedia) {
+            body = yield response.blob();
+          } else if (respJSON) {
+            body = yield response.json();
+          } else {
+            throw new InvalidResponseError();
+          }
+        } catch (e) {
+          if (e.name === "AbortError" || e instanceof InvalidResponseError) {
+            throw e;
+          }
+          throw new InvalidResponseError();
+        }
+        if (400 <= response.status && response.status <= 599) {
+          throw new ServerResponseError(body);
+        }
+        return body;
+      });
+      if (cacheEngine && ((_b = opt.method) == null ? void 0 : _b.toUpperCase()) === "GET") {
+        const props = cacheProps ? cacheProps : __spreadValues$7({}, objectRemoveEmpty({
+          withCredentials,
+          responseType
+        }));
+        return cacheEngine.add(cacheName || url, makeRequest, {
+          props,
+          expirationTime: cache ? void 0 : 500
+        });
+      }
+      return makeRequest();
+    });
+  }
+
+  var __defProp$8 = Object.defineProperty;
+  var __defProps$4 = Object.defineProperties;
+  var __getOwnPropDescs$4 = Object.getOwnPropertyDescriptors;
+  var __getOwnPropSymbols$6 = Object.getOwnPropertySymbols;
+  var __hasOwnProp$6 = Object.prototype.hasOwnProperty;
+  var __propIsEnum$6 = Object.prototype.propertyIsEnumerable;
+  var __defNormalProp$8 = (obj, key, value) => key in obj ? __defProp$8(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+  var __spreadValues$6 = (a, b) => {
+    for (var prop in b || (b = {}))
+      if (__hasOwnProp$6.call(b, prop))
+        __defNormalProp$8(a, prop, b[prop]);
+    if (__getOwnPropSymbols$6)
+      for (var prop of __getOwnPropSymbols$6(b)) {
+        if (__propIsEnum$6.call(b, prop))
+          __defNormalProp$8(a, prop, b[prop]);
+      }
+    return a;
+  };
+  var __spreadProps$4 = (a, b) => __defProps$4(a, __getOwnPropDescs$4(b));
+  var __objRest$1 = (source, exclude) => {
+    var target = {};
+    for (var prop in source)
+      if (__hasOwnProp$6.call(source, prop) && exclude.indexOf(prop) < 0)
+        target[prop] = source[prop];
+    if (source != null && __getOwnPropSymbols$6)
+      for (var prop of __getOwnPropSymbols$6(source)) {
+        if (exclude.indexOf(prop) < 0 && __propIsEnum$6.call(source, prop))
+          target[prop] = source[prop];
+      }
+    return target;
+  };
+  var __async$5 = (__this, __arguments, generator) => {
+    return new Promise((resolve, reject) => {
+      var fulfilled = (value) => {
+        try {
+          step(generator.next(value));
+        } catch (e) {
+          reject(e);
+        }
+      };
+      var rejected = (value) => {
+        try {
+          step(generator.throw(value));
+        } catch (e) {
+          reject(e);
+        }
+      };
+      var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+      step((generator = generator.apply(__this, __arguments)).next());
+    });
+  };
+  function routeURL(name, baseUrl, routeData, ...rest) {
+    const [template, ...params] = routeData[name];
+    const first = rest[0];
+    let sub;
+    if (first === void 0) {
+      sub = [];
+    } else if (typeof first === "object" && first !== null) {
+      if (rest.length > 1) {
+        throw new Error("Too many arguments for route(name, object)!");
+      }
+      sub = [];
+      for (const [p, v] of Object.entries(first)) {
+        sub[params.indexOf(p)] = String(v);
+      }
+    } else {
+      sub = rest.map((v) => String(v));
+    }
+    return fixUrlStr(
+      baseUrl + template.replace(/\{(\w+)\}/g, function(m, a) {
+        const idx = parseInt(a);
+        const value = sub[idx];
+        if (value === void 0) {
+          const msg = `Undefined parameter ${idx} in "${template}".`;
+          throw new Error(msg);
+        }
+        return String(value);
+      })
+    );
+  }
+  function route(name, connector, ...rest) {
+    const result = {
+      url: (opt) => __async$5(this, null, function* () {
+        var _a;
+        const routeData = yield connector.connect();
+        const template = routeURL(
+          name,
+          (_a = connector.options.baseUrl) != null ? _a : "",
+          routeData,
+          ...rest
+        );
+        return generateUrl(template, opt == null ? void 0 : opt.query);
+      })
+    };
+    const methods = ["get", "post", "put", "delete", "patch"];
+    for (const method of methods) {
+      const methodResp = (requestOptions) => __async$5(this, null, function* () {
+        var _b;
+        const _a = requestOptions || {}, { headers: optHeaders } = _a, restOpt = __objRest$1(_a, ["headers"]);
+        const routeData = yield connector.connect();
+        const template = routeURL(
+          name,
+          (_b = connector.options.baseUrl) != null ? _b : "",
+          routeData,
+          ...rest
+        );
+        const headers = objectRemoveEmpty(__spreadValues$6(__spreadValues$6({}, connector.getAuthorizationHeaders()), optHeaders != null ? optHeaders : {}));
+        return request(
+          template,
+          __spreadProps$4(__spreadValues$6({
+            headers
+          }, restOpt), {
+            method
+          }),
+          connector.cache
+        );
+      });
+      result[method] = methodResp;
+    }
+    return result;
+  }
+
+  function isObject(val) {
+    return Object.prototype.toString.call(val) === "[object Object]";
+  }
+
+  let loadData;
+  {
+    loadData = (url, callback, options = {}, error, onCancel) => {
+      options.method = options.method || "GET";
+      const xhr = new XMLHttpRequest();
+      xhr.open(options.method || "GET", url, true);
+      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.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);
+          }
+        }
+      };
+      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 !== void 0) {
+        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);
+    };
+  }
+
+  const templateRe = /\{ *([\w_-]+) *\}/g;
+  function template(str, data) {
+    return str.replace(templateRe, (s, key) => {
+      let value = data[key];
+      if (value === void 0) {
+        throw new Error("No value provided for letiable " + s);
+      } else if (typeof value === "function") {
+        value = value(data);
+      }
+      return value;
+    });
+  }
+
+  var __defProp$7 = Object.defineProperty;
+  var __defProps$3 = Object.defineProperties;
+  var __getOwnPropDescs$3 = Object.getOwnPropertyDescriptors;
+  var __getOwnPropSymbols$5 = Object.getOwnPropertySymbols;
+  var __hasOwnProp$5 = Object.prototype.hasOwnProperty;
+  var __propIsEnum$5 = Object.prototype.propertyIsEnumerable;
+  var __defNormalProp$7 = (obj, key, value) => key in obj ? __defProp$7(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+  var __spreadValues$5 = (a, b) => {
+    for (var prop in b || (b = {}))
+      if (__hasOwnProp$5.call(b, prop))
+        __defNormalProp$7(a, prop, b[prop]);
+    if (__getOwnPropSymbols$5)
+      for (var prop of __getOwnPropSymbols$5(b)) {
+        if (__propIsEnum$5.call(b, prop))
+          __defNormalProp$7(a, prop, b[prop]);
+      }
+    return a;
+  };
+  var __spreadProps$3 = (a, b) => __defProps$3(a, __getOwnPropDescs$3(b));
+  var __objRest = (source, exclude) => {
+    var target = {};
+    for (var prop in source)
+      if (__hasOwnProp$5.call(source, prop) && exclude.indexOf(prop) < 0)
+        target[prop] = source[prop];
+    if (source != null && __getOwnPropSymbols$5)
+      for (var prop of __getOwnPropSymbols$5(source)) {
+        if (exclude.indexOf(prop) < 0 && __propIsEnum$5.call(source, prop))
+          target[prop] = source[prop];
+      }
+    return target;
+  };
+  var __publicField$4 = (obj, key, value) => __defNormalProp$7(obj, typeof key !== "symbol" ? key + "" : key, value);
+  var __async$4 = (__this, __arguments, generator) => {
+    return new Promise((resolve, reject) => {
+      var fulfilled = (value) => {
+        try {
+          step(generator.next(value));
+        } catch (e) {
+          reject(e);
+        }
+      };
+      var rejected = (value) => {
+        try {
+          step(generator.throw(value));
+        } catch (e) {
+          reject(e);
+        }
+      };
+      var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+      step((generator = generator.apply(__this, __arguments)).next());
+    });
+  };
+  let ID = 0;
+  let REQUEST_ID = 0;
+  class NgwConnector {
+    constructor(options) {
+      this.options = options;
+      __publicField$4(this, "id", ID++);
+      __publicField$4(this, "emitter", new EventEmitter());
+      __publicField$4(this, "user");
+      __publicField$4(this, "cache");
+      __publicField$4(this, "withCredentials");
+      __publicField$4(this, "client", `NextGIS-NGW-Connector/${pkg.version}`);
+      __publicField$4(this, "routeStr", "/api/component/pyramid/route");
+      __publicField$4(this, "activeRequests", {});
+      __publicField$4(this, "requestTransform");
+      const exist = findConnector(options);
+      this.cache = new Cache({ namespace: options.cacheId });
+      if (exist) {
+        return exist;
+      } else {
+        const { route: route2, requestTransform, withCredentials } = this.options;
+        if (route2) {
+          this.routeStr = route2;
+        }
+        if (requestTransform) {
+          this.requestTransform = requestTransform;
+        }
+        if (withCredentials !== void 0) {
+          this.withCredentials = withCredentials;
+        }
+        addConnector(this);
+      }
+    }
+    /**
+     * Clear the cache.
+     */
+    clearCache() {
+      this.cache.clean();
+    }
+    setRequestTransform(requestTransform) {
+      this.requestTransform = requestTransform;
+    }
+    /**
+     * Fast way to specify the connection address to NextGIS Web.
+     * The current connection will be severed.
+     * @param baseUrl - NGW url
+     */
+    setNgw(baseUrl) {
+      this.logout();
+      this.options.baseUrl = baseUrl;
+      addConnector(this);
+    }
+    /**
+     * Establishing a connection with NextGIS Web to fulfill all other requests.
+     * @remarks
+     * This method need not be called manually as it is used when forming a request in {@link apiRequest | apiRequest}.
+     * Can be used to check connection.
+     * @example
+     * ```javascript
+     * const connector = new NgwConnector({ baseUrl: 'https://demo.nextgis.com' });
+     * connector.connect()
+     *   .then(() => console.log('Ok'))
+     *   .catch((er) => console.log('Connection problem', er));
+     * ```
+     */
+    connect() {
+      return __async$4(this, null, function* () {
+        const auth = this.options.auth;
+        if (auth) {
+          const { login, password } = auth;
+          if (login && password) {
+            yield this._login({ login, password });
+          }
+        }
+        const routeUrl = `${this.routeStr}?client=${this.client}`;
+        return yield this.makeQuery(
+          routeUrl,
+          {},
+          {
+            cacheName: "route",
+            cache: true,
+            cacheProps: {
+              id: this.id,
+              auth,
+              baseUrl: this.options.baseUrl
+            }
+          }
+        );
+      });
+    }
+    /**
+     * Quick way to change NextGIS Web user.
+     * @param credentials - New user credentials
+     */
+    login(credentials, options) {
+      this.logout();
+      addConnector(this);
+      return this._login(credentials, options);
+    }
+    /**
+     * Disconnecting a user. Aborting all current requests
+     */
+    logout() {
+      this.abort();
+      removeConnector(this);
+      this.options.auth = void 0;
+      this.user = void 0;
+      this.clearCache();
+      this.emitter.emit("logout");
+    }
+    getUserInfo(credentials, options) {
+      return __async$4(this, null, function* () {
+        if (this.user && this.user.id) {
+          return this.user;
+        }
+        if (credentials) {
+          this.options.auth = credentials;
+        }
+        const options_ = __spreadValues$5({
+          headers: this.getAuthorizationHeaders(credentials),
+          cache: true
+        }, options);
+        return this.makeQuery(
+          "/api/component/auth/current_user",
+          {},
+          options_
+        );
+      });
+    }
+    /**
+     * Obtaining the required Headers for authentication of requests in the NGW.
+     */
+    getAuthorizationHeaders(credentials) {
+      const client = this.makeClientId(credentials);
+      if (client) {
+        return {
+          Authorization: `Basic ${client}`
+        };
+      }
+      return {};
+    }
+    makeClientId(credentials) {
+      credentials = credentials || this.options.auth;
+      if (credentials) {
+        const { login, password } = credentials;
+        const encodedStr = [login, password].map(encodeURIComponent).join(":");
+        {
+          return window.btoa(encodedStr);
+        }
+      }
+    }
+    /** Stop all api requests */
+    abort() {
+      for (const abortController of Object.values(this.activeRequests)) {
+        abortController.abort();
+      }
+      this.activeRequests = {};
+    }
+    getActiveApiRequests() {
+      return __spreadValues$5({}, this.activeRequests);
+    }
+    route(name, ...rest) {
+      return route(name, this, ...rest);
+    }
+    /**
+     * Send request to NGW.
+     * @param url - URL address to NGW
+     * @param params - Query params
+     * @param options - Request options
+     */
+    makeQuery(_0, _1) {
+      return __async$4(this, arguments, function* (url, params, options = {}) {
+        var _b;
+        url = (this.options.baseUrl ? this.options.baseUrl : "") + url;
+        if (!url) {
+          throw new Error("Empty `url` not allowed");
+        }
+        if (params) {
+          const _a = params, restParams = __objRest(_a, ["paramList"]);
+          url = template(url, restParams);
+        }
+        url = encodeURI(fixUrlStr(url));
+        options = __spreadValues$5({ withCredentials: this.withCredentials }, options);
+        const {
+          cache,
+          signal: externalSignal,
+          method = "GET",
+          headers,
+          cacheName,
+          cacheProps,
+          responseType,
+          withCredentials
+        } = options;
+        const internalAbortController = new AbortController();
+        const internalSignal = internalAbortController.signal;
+        if (externalSignal) {
+          if (externalSignal.aborted) {
+            throw new AbortError();
+          }
+          externalSignal.addEventListener("abort", () => {
+            internalAbortController.abort();
+          });
+        }
+        options.signal = internalSignal;
+        const createPromise = () => __async$4(this, null, function* () {
+          const id = REQUEST_ID++;
+          this.activeRequests[id] = internalAbortController;
+          try {
+            return this._loadData(url, options);
+          } finally {
+            this._cleanActiveRequest(id);
+          }
+        });
+        if (method === "GET") {
+          const cacheOptions = cacheProps ? cacheProps : __spreadProps$3(__spreadValues$5({}, objectRemoveEmpty({
+            headers,
+            withCredentials,
+            responseType,
+            baseUrl: this.options.baseUrl,
+            userId: (_b = this.user) == null ? void 0 : _b.id
+          })), {
+            params
+          });
+          return this.cache.add(cacheName || url, createPromise, {
+            props: cacheOptions,
+            expirationTime: cache ? void 0 : 500
+          });
+        }
+        return createPromise();
+      });
+    }
+    _loadData(url, options) {
+      options.responseType = options.responseType || "json";
+      return new Promise((resolve, reject) => {
+        var _a;
+        if (this.user) {
+          options = options || {};
+          options.headers = __spreadValues$5(__spreadValues$5({}, this.getAuthorizationHeaders()), options.headers);
+        }
+        if (this.requestTransform) {
+          const [transUrl, transOptions] = this.requestTransform(url, options);
+          url = transUrl;
+          options = transOptions;
+        }
+        let runOnAbort = void 0;
+        loadData(url, resolve, options, reject, (handler) => {
+          runOnAbort = handler;
+        });
+        (_a = options.signal) == null ? void 0 : _a.addEventListener("abort", () => {
+          if (runOnAbort !== void 0) {
+            runOnAbort();
+          }
+          reject(new AbortError());
+        });
+      }).catch((httpError) => {
+        if (httpError.name !== "AbortError") {
+          {
+            console.warn("DEV WARN", httpError);
+          }
+          const er = this._handleHttpError(httpError);
+          if (er) {
+            throw er;
+          }
+        }
+        throw httpError;
+      });
+    }
+    _login(credentials, options) {
+      return __async$4(this, null, function* () {
+        try {
+          const data = yield this.getUserInfo(credentials, options);
+          this.user = data;
+          this.emitter.emit("login", data);
+          return data;
+        } catch (er) {
+          this.emitter.emit("login:error", er);
+          throw er;
+        }
+      });
+    }
+    _cleanActiveRequest(requestId) {
+      delete this.activeRequests[requestId];
+    }
+    _handleHttpError(er) {
+      if (er) {
+        if (er instanceof NgwError) {
+          if (er.exception === "nextgisweb.resource.exception.ResourceNotFound") {
+            throw new ResourceNotFoundError(er);
+          } else if (er.exception === "nextgisweb.core.exception.InsufficientPermissions") {
+            throw new InsufficientPermissionsError(er);
+          }
+        }
+      }
+      return er;
+    }
+  }
+  __publicField$4(NgwConnector, "errors", errors);
+
+  function resourceCompare(res1, res2) {
+    return objectDeepEqual(res1, res2);
+  }
+
+  const exclude = ["description"];
+  function resourceToQuery(resource, prefix = "") {
+    prefix = prefix ? prefix + "__" : "";
+    const query = {};
+    for (const [key, value] of Object.entries(resource)) {
+      if (exclude.indexOf(key) === -1) {
+        if (isObject(value)) {
+          if (key === "owner_user") {
+            const children = resourceToQuery(
+              value,
+              key
+            );
+            Object.assign(query, children);
+          } else if (key === "parent" && "id" in value) {
+            query.parent_id = value.id;
+          }
+        } else if (defined(value)) {
+          query[prefix + key] = value;
+        }
+      }
+    }
+    return query;
+  }
+
+  var __defProp$6 = Object.defineProperty;
+  var __defProps$2 = Object.defineProperties;
+  var __getOwnPropDescs$2 = Object.getOwnPropertyDescriptors;
+  var __getOwnPropSymbols$4 = Object.getOwnPropertySymbols;
+  var __hasOwnProp$4 = Object.prototype.hasOwnProperty;
+  var __propIsEnum$4 = Object.prototype.propertyIsEnumerable;
+  var __defNormalProp$6 = (obj, key, value) => key in obj ? __defProp$6(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+  var __spreadValues$4 = (a, b) => {
+    for (var prop in b || (b = {}))
+      if (__hasOwnProp$4.call(b, prop))
+        __defNormalProp$6(a, prop, b[prop]);
+    if (__getOwnPropSymbols$4)
+      for (var prop of __getOwnPropSymbols$4(b)) {
+        if (__propIsEnum$4.call(b, prop))
+          __defNormalProp$6(a, prop, b[prop]);
+      }
+    return a;
+  };
+  var __spreadProps$2 = (a, b) => __defProps$2(a, __getOwnPropDescs$2(b));
+  var __publicField$3 = (obj, key, value) => __defNormalProp$6(obj, typeof key !== "symbol" ? key + "" : key, value);
+  var __async$3 = (__this, __arguments, generator) => {
+    return new Promise((resolve, reject) => {
+      var fulfilled = (value) => {
+        try {
+          step(generator.next(value));
+        } catch (e) {
+          reject(e);
+        }
+      };
+      var rejected = (value) => {
+        try {
+          step(generator.throw(value));
+        } catch (e) {
+          reject(e);
+        }
+      };
+      var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+      step((generator = generator.apply(__this, __arguments)).next());
+    });
+  };
+  class ResourcesControl {
+    constructor({
+      connector,
+      cacheId
+    }) {
+      __publicField$3(this, "cache");
+      __publicField$3(this, "connector");
+      this.connector = connector;
+      this.cache = new Cache({ namespace: cacheId });
+    }
+    // -------------------------------------------------------------------------
+    // Resource Methods
+    // -------------------------------------------------------------------------
+    /**
+     * Receive resource from NGW by id, keyname or search-object parameter.
+     * @param resource - Resource id, keyname or search-object
+     *
+     * @remarks
+     * Fetching resource would be cached to speed up next call
+     */
+    getOne(resource, requestOptions) {
+      const opt = __spreadValues$4({}, requestOptions);
+      if (typeof resource === "string") ; else if (typeof resource === "number") ; else if (isObject(resource)) {
+        if (resource.id !== void 0) {
+          resource.id;
+        } else {
+          if (resource.keyname) {
+            resource.keyname;
+          }
+          if (resource.display_name) {
+            resource.display_name;
+          }
+        }
+      }
+      if (typeof resource === "string") {
+        return this._fetchResourceBy({ keyname: resource }, opt);
+      } else if (typeof resource === "number") {
+        return this._fetchResourceById(resource, opt);
+      } else if (isObject(resource)) {
+        return this._fetchResourceBy(resource, opt);
+      }
+      return Promise.resolve(void 0);
+    }
+    getOneOrFail(resource, requestOptions) {
+      return this.getOne(resource, requestOptions).then((res) => {
+        if (res) {
+          return res;
+        }
+        throw new ResourceNotFoundError();
+      });
+    }
+    /**
+     * A fast way to retrieve resource ID for any resource definition.
+     * @param resource - Any available resource definition
+     *
+     * @remarks
+     * There are situations when exactly the resource id is needed
+     * (for example, to compose the correct request to the api)
+     * then this method will come in handy to facilitate the extraction of the identifier
+     * if the resource is specified through a keyname or other parameters.
+     */
+    getId(resource, requestOptions) {
+      if (typeof resource === "number") {
+        return Promise.resolve(resource);
+      } else if (typeof resource === "string" || isObject(resource)) {
+        return this.getOne(resource, requestOptions).then((res) => {
+          if (res) {
+            return res.resource.id;
+          }
+        });
+      }
+      return Promise.resolve(void 0);
+    }
+    /**
+     * A fast way to retrieve resource ID for any resource definition.
+     * @param resource - Any available resource definition
+     *
+     * @remarks
+     * Similar with {@link NgwConnector.getResourceId | getResourceId} but rise error if resource is not exist.
+     * To not make one more checks if the resource is definitely exists
+     */
+    getIdOrFail(resource, requestOptions) {
+      return this.getId(resource, requestOptions).then((resp) => {
+        if (resp === void 0) {
+          throw new Error();
+        }
+        return resp;
+      });
     }
     getMany(resource, requestOptions) {
       return this._resourceCacheFilter(resource).then((items) => {
@@ -1088,9 +2172,11 @@ var Geocoder = (function (exports) {
           } else {
             Object.assign(query, resourceToQuery(resource));
           }
-          return this.connector.get("resource.search", requestOptions, __spreadValues$5({
-            serialization: "full"
-          }, query)).then((resources) => {
+          return this.connector.route("resource.search").get(__spreadProps$2(__spreadValues$4({}, requestOptions), {
+            query: __spreadValues$4({
+              serialization: "full"
+            }, query)
+          })).then((resources) => {
             if ((requestOptions == null ? void 0 : requestOptions.cache) && resources) {
               for (const x of resources) {
                 this.cache.add("resource.item", Promise.resolve(x), {
@@ -1106,7 +2192,8 @@ var Geocoder = (function (exports) {
     }
     getParent(resource, requestOptions) {
       return this.getOne(resource, requestOptions).then((child) => {
-        if (child) {
+        var _a, _b;
+        if ((_b = (_a = child == null ? void 0 : child.resource) == null ? void 0 : _a.parent) == null ? void 0 : _b.id) {
           return this.getOne(child.resource.parent.id, requestOptions);
         }
         return Promise.resolve(void 0);
@@ -1138,10 +2225,21 @@ var Geocoder = (function (exports) {
         }
       });
     }
-    _getChildrenOf(parent, requestOptions, _items = []) {
-      return this.connector.get("resource.collection", requestOptions, {
-        parent
-      }).then((items) => {
+    _getChildrenOf(_0, _1) {
+      return __async$3(this, arguments, function* (parentDef, requestOptions, _items = []) {
+        let parent = void 0;
+        if (typeof parentDef === "string") {
+          parent = yield this.getId(parentDef, requestOptions);
+        } else if (typeof parentDef === "object") {
+          parent = parentDef.id;
+        } else {
+          parent = parentDef;
+        }
+        const items = yield this.connector.route("resource.collection").get(__spreadProps$2(__spreadValues$4({}, requestOptions), {
+          query: {
+            parent
+          }
+        }));
         const recursivePromises = [];
         for (const item of items) {
           if (requestOptions == null ? void 0 : requestOptions.cache) {
@@ -1165,7 +2263,7 @@ var Geocoder = (function (exports) {
       });
     }
     _cleanResourceItemCache(id) {
-      return __async$4(this, null, function* () {
+      return __async$3(this, null, function* () {
         var _a;
         const all = this.cache.all();
         const toDelete = [];
@@ -1190,7 +2288,7 @@ var Geocoder = (function (exports) {
       });
     }
     _fetchResourceById(id, requestOptions) {
-      return this.connector.get("resource.item", requestOptions, { id });
+      return this.connector.route("resource.item", { id }).get(requestOptions);
     }
     _fetchResourceBy(resource, requestOptions) {
       return this.getMany(resource, requestOptions).then((resources) => {
@@ -1211,86 +2309,30 @@ var Geocoder = (function (exports) {
               }
               return resourceCompare(resource, x.resource);
             }
-          });
-          return items;
-        }
-      );
-    }
-  }
-
-  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 {
-          return true;
-        }
-      }
-    });
-  }
-  function removeConnector(connector) {
-    const index = CONNECTORS.indexOf(connector);
-    if (index !== -1) {
-      CONNECTORS.splice(index, 1);
-    }
-  }
-
-  class AbortError extends Error {
-    constructor(message = "AbortError") {
-      super(message);
-      this.name = "AbortError";
-    }
-  }
-
-  var __defProp$7 = Object.defineProperty;
-  var __defNormalProp$7 = (obj, key, value) => key in obj ? __defProp$7(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-  var __publicField$4 = (obj, key, value) => __defNormalProp$7(obj, typeof key !== "symbol" ? key + "" : key, value);
-  class InsufficientPermissionsError extends NgwError {
-    constructor(obj) {
-      super(obj);
-      __publicField$4(this, "name", "InsufficientPermissionsError");
-      __publicField$4(this, "exception", "nextgisweb.core.exception.InsufficientPermissions");
-      Object.setPrototypeOf(this, InsufficientPermissionsError.prototype);
-    }
-  }
-
-  const templateRe = /\{ *([\w_-]+) *\}/g;
-  function template(str, data) {
-    return str.replace(templateRe, (s, key) => {
-      let value = data[key];
-      if (value === void 0) {
-        throw new Error("No value provided for letiable " + s);
-      } else if (typeof value === "function") {
-        value = value(data);
-      }
-      return value;
-    });
+          });
+          return items;
+        }
+      );
+    }
   }
 
-  var __defProp$6 = Object.defineProperty;
-  var __getOwnPropSymbols$4 = Object.getOwnPropertySymbols;
-  var __hasOwnProp$4 = Object.prototype.hasOwnProperty;
-  var __propIsEnum$4 = Object.prototype.propertyIsEnumerable;
-  var __defNormalProp$6 = (obj, key, value) => key in obj ? __defProp$6(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-  var __spreadValues$4 = (a, b) => {
+  var __defProp$5 = Object.defineProperty;
+  var __getOwnPropSymbols$3 = Object.getOwnPropertySymbols;
+  var __hasOwnProp$3 = Object.prototype.hasOwnProperty;
+  var __propIsEnum$3 = Object.prototype.propertyIsEnumerable;
+  var __defNormalProp$5 = (obj, key, value) => key in obj ? __defProp$5(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+  var __spreadValues$3 = (a, b) => {
     for (var prop in b || (b = {}))
-      if (__hasOwnProp$4.call(b, prop))
-        __defNormalProp$6(a, prop, b[prop]);
-    if (__getOwnPropSymbols$4)
-      for (var prop of __getOwnPropSymbols$4(b)) {
-        if (__propIsEnum$4.call(b, prop))
-          __defNormalProp$6(a, prop, b[prop]);
+      if (__hasOwnProp$3.call(b, prop))
+        __defNormalProp$5(a, prop, b[prop]);
+    if (__getOwnPropSymbols$3)
+      for (var prop of __getOwnPropSymbols$3(b)) {
+        if (__propIsEnum$3.call(b, prop))
+          __defNormalProp$5(a, prop, b[prop]);
       }
     return a;
   };
-  var __async$3 = (__this, __arguments, generator) => {
+  var __async$2 = (__this, __arguments, generator) => {
     return new Promise((resolve, reject) => {
       var fulfilled = (value) => {
         try {
@@ -1311,7 +2353,7 @@ var Geocoder = (function (exports) {
     });
   };
   function apiRequest(opt) {
-    return __async$3(this, null, function* () {
+    return __async$2(this, null, function* () {
       const { params, name, connector, requestOptions } = opt;
       const apiItems = yield connector.connect();
       let apiItem = apiItems && apiItems[name];
@@ -1340,334 +2382,48 @@ var Geocoder = (function (exports) {
             });
           }
           for (const p in params) {
-            if (apiItem.indexOf(p) === -1) {
-              paramArray.push(`${p}=${params[p]}`);
-            }
-          }
-          if (paramArray.length) {
-            url = `${url}?${paramArray.join("&")}`;
-          }
-        }
-        if (url) {
-          return connector.makeQuery(url, params, __spreadValues$4({
-            cacheName: name
-          }, requestOptions));
-        } else {
-          throw new Error("Request URL is not set");
-        }
-      } else {
-        return void 0;
-      }
-    });
-  }
-
-  var __defProp$5 = Object.defineProperty;
-  var __defNormalProp$5 = (obj, key, value) => key in obj ? __defProp$5(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-  var __publicField$3 = (obj, key, value) => __defNormalProp$5(obj, key + "" , value);
-  class NetworkError extends Error {
-    constructor(url) {
-      super();
-      __publicField$3(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}`;
-    }
-  }
-
-  let loadData;
-  {
-    loadData = (url, callback, options = {}, error, onCancel) => {
-      options.method = options.method || "GET";
-      const xhr = new XMLHttpRequest();
-      xhr.open(options.method || "GET", url, true);
-      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.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);
-          }
-        }
-      };
-      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 !== void 0) {
-        xhr.withCredentials = options.withCredentials;
-      }
-      let data;
-      if (options.file) {
-        data = new FormData();
-        data.append("file", options.file);
-        if (options.data) {
-          for (const d in options.data) {
-            data.append(d, data[d]);
-          }
-        }
-      } else {
-        data = options.data ? typeof options.data === "string" ? options.data : JSON.stringify(options.data) : null;
-      }
-      if (onCancel) {
-        onCancel(() => {
-          xhr.abort();
-        });
-      }
-      xhr.send(data);
-    };
-  }
-
-  var __defProp$4 = Object.defineProperty;
-  var __defProps$2 = Object.defineProperties;
-  var __getOwnPropDescs$2 = Object.getOwnPropertyDescriptors;
-  var __getOwnPropSymbols$3 = Object.getOwnPropertySymbols;
-  var __hasOwnProp$3 = Object.prototype.hasOwnProperty;
-  var __propIsEnum$3 = Object.prototype.propertyIsEnumerable;
-  var __defNormalProp$4 = (obj, key, value) => key in obj ? __defProp$4(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-  var __spreadValues$3 = (a, b) => {
-    for (var prop in b || (b = {}))
-      if (__hasOwnProp$3.call(b, prop))
-        __defNormalProp$4(a, prop, b[prop]);
-    if (__getOwnPropSymbols$3)
-      for (var prop of __getOwnPropSymbols$3(b)) {
-        if (__propIsEnum$3.call(b, prop))
-          __defNormalProp$4(a, prop, b[prop]);
-      }
-    return a;
-  };
-  var __spreadProps$2 = (a, b) => __defProps$2(a, __getOwnPropDescs$2(b));
-  var __objRest = (source, exclude) => {
-    var target = {};
-    for (var prop in source)
-      if (__hasOwnProp$3.call(source, prop) && exclude.indexOf(prop) < 0)
-        target[prop] = source[prop];
-    if (source != null && __getOwnPropSymbols$3)
-      for (var prop of __getOwnPropSymbols$3(source)) {
-        if (exclude.indexOf(prop) < 0 && __propIsEnum$3.call(source, prop))
-          target[prop] = source[prop];
-      }
-    return target;
-  };
-  var __publicField$2 = (obj, key, value) => __defNormalProp$4(obj, typeof key !== "symbol" ? key + "" : key, value);
-  var __async$2 = (__this, __arguments, generator) => {
-    return new Promise((resolve, reject) => {
-      var fulfilled = (value) => {
-        try {
-          step(generator.next(value));
-        } catch (e) {
-          reject(e);
-        }
-      };
-      var rejected = (value) => {
-        try {
-          step(generator.throw(value));
-        } catch (e) {
-          reject(e);
-        }
-      };
-      var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
-      step((generator = generator.apply(__this, __arguments)).next());
-    });
-  };
-  let ID = 0;
-  let REQUEST_ID = 0;
-  class NgwConnector {
-    constructor(options) {
-      this.options = options;
-      __publicField$2(this, "id", ID++);
-      __publicField$2(this, "emitter", new EventEmitter());
-      __publicField$2(this, "user");
-      __publicField$2(this, "resources");
-      __publicField$2(this, "cache");
-      __publicField$2(this, "routeStr", "/api/component/pyramid/route");
-      __publicField$2(this, "activeRequests", {});
-      __publicField$2(this, "requestTransform");
-      const exist = findConnector(options);
-      this.cache = new Cache({ namespace: options.cacheId });
-      if (exist) {
-        return exist;
-      } else {
-        if (this.options.route) {
-          this.routeStr = this.options.route;
-        }
-        if (this.options.requestTransform) {
-          this.requestTransform = this.options.requestTransform;
-        }
-        this.resources = new ResourcesControl({
-          connector: this,
-          cacheId: options.cacheId
-        });
-        addConnector(this);
-      }
-    }
-    static create(options) {
-      return new this(options);
-    }
-    /**
-     * Clear the cache.
-     */
-    clearCache() {
-      this.cache.clean();
-      this.resources.cache.clean();
-    }
-    setRequestTransform(requestTransform) {
-      this.requestTransform = requestTransform;
-    }
-    /**
-     * Fast way to specify the connection address to NextGIS Web.
-     * The current connection will be severed.
-     * @param baseUrl - NGW url
-     */
-    setNgw(baseUrl) {
-      this.logout();
-      this.options.baseUrl = baseUrl;
-      addConnector(this);
-    }
-    /**
-     * Establishing a connection with NextGIS Web to fulfill all other requests.
-     * @remarks
-     * This method need not be called manually as it is used when forming a request in {@link apiRequest | apiRequest}.
-     * Can be used to check connection.
-     * @example
-     * ```javascript
-     * const connector = new NgwConnector({baseUrl: 'https://demo.nextgis.com'});
-     * connector.connect()
-     *   .then(() => console.log('Ok'))
-     *   .catch((er) => console.log('Connection problem', er));
-     * ```
-     */
-    connect() {
-      return __async$2(this, null, function* () {
-        const auth = this.options.auth;
-        if (auth) {
-          const { login, password } = auth;
-          if (login && password) {
-            yield this._login({ login, password });
-          }
-        }
-        return yield this.makeQuery(
-          this.routeStr,
-          {},
-          {
-            cacheName: "route",
-            cache: true,
-            cacheProps: {
-              id: this.id,
-              auth,
-              baseUrl: this.options.baseUrl
+            if (apiItem.indexOf(p) === -1) {
+              paramArray.push(`${p}=${params[p]}`);
             }
           }
-        );
-      });
-    }
-    /**
-     * Quick way to change NextGIS Web user.
-     * @param credentials - New user credentials
-     */
-    login(credentials, options) {
-      this.logout();
-      addConnector(this);
-      return this._login(credentials, options);
-    }
-    /**
-     * Disconnecting a user. Aborting all current requests
-     */
-    logout() {
-      this.abort();
-      removeConnector(this);
-      this.options.auth = void 0;
-      this.user = void 0;
-      this.clearCache();
-      this.emitter.emit("logout");
-    }
-    getUserInfo(credentials, options) {
-      return __async$2(this, null, function* () {
-        if (this.user && this.user.id) {
-          return this.user;
+          if (paramArray.length) {
+            url = `${url}?${paramArray.join("&")}`;
+          }
         }
-        if (credentials) {
-          this.options.auth = credentials;
+        if (url) {
+          return connector.makeQuery(url, params, __spreadValues$3({
+            cacheName: name
+          }, requestOptions));
+        } else {
+          throw new Error("Request URL is not set");
         }
-        const options_ = __spreadValues$3({
-          headers: this.getAuthorizationHeaders(credentials)
-        }, options);
-        return this.makeQuery(
-          "/api/component/auth/current_user",
-          {},
-          options_
-        );
+      } else {
+        return void 0;
+      }
+    });
+  }
+
+  var __defProp$4 = Object.defineProperty;
+  var __defNormalProp$4 = (obj, key, value) => key in obj ? __defProp$4(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+  var __publicField$2 = (obj, key, value) => __defNormalProp$4(obj, key + "" , value);
+  class NgwConnectorExtended extends NgwConnector {
+    constructor(options) {
+      super(options);
+      __publicField$2(this, "resources");
+      this.resources = new ResourcesControl({
+        connector: this,
+        cacheId: options.cacheId
       });
     }
+    static create(options) {
+      return new this(options);
+    }
     /**
-     * Obtaining the required Headers for authentication of requests in the NGW.
+     * Clear the cache.
      */
-    getAuthorizationHeaders(credentials) {
-      const client = this.makeClientId(credentials);
-      if (client) {
-        return {
-          Authorization: `Basic ${client}`
-        };
-      }
-    }
-    makeClientId(credentials) {
-      credentials = credentials || this.options.auth;
-      if (credentials) {
-        const { login, password } = credentials;
-        const str = `${login}:${password}`;
-        const encodedStr = encodeURIComponent(str);
-        {
-          return window.btoa(encodedStr);
-        }
-      }
-    }
-    /** Stop all api requests */
-    abort() {
-      for (const abortController of Object.values(this.activeRequests)) {
-        abortController.abort();
-      }
-      this.activeRequests = {};
-    }
-    getActiveApiRequests() {
-      return __spreadValues$3({}, this.activeRequests);
+    clearCache() {
+      super.clearCache();
+      this.resources.cache.clean();
     }
     /**
      * Send request to NGW api router.
@@ -1786,74 +2542,6 @@ var Geocoder = (function (exports) {
         options
       );
     }
-    /**
-     * Send request to NGW.
-     * @param url - URL address to NGW
-     * @param params - Query params
-     * @param options - Request options
-     */
-    makeQuery(_0, _1) {
-      return __async$2(this, arguments, function* (url, params, options = {}) {
-        var _b;
-        url = (this.options.baseUrl ? this.options.baseUrl : "") + url;
-        if (!url) {
-          throw new Error("Empty `url` not allowed");
-        }
-        if (params) {
-          const _a = params, restParams = __objRest(_a, ["paramList"]);
-          url = template(url, restParams);
-        }
-        url = encodeURI(fixUrlStr(url));
-        const {
-          cache,
-          signal: externalSignal,
-          method = "GET",
-          headers,
-          cacheName,
-          cacheProps,
-          responseType,
-          withCredentials
-        } = options;
-        const internalAbortController = new AbortController();
-        const internalSignal = internalAbortController.signal;
-        if (externalSignal) {
-          if (externalSignal.aborted) {
-            throw new AbortError();
-          }
-          externalSignal.addEventListener("abort", () => {
-            internalAbortController.abort();
-          });
-        }
-        options.signal = internalSignal;
-        const createPromise = () => __async$2(this, null, function* () {
-          const id = REQUEST_ID++;
-          this.activeRequests[id] = internalAbortController;
-          try {
-            return this._loadData(url, options);
-          } finally {
-            this._cleanActiveRequest(id);
-          }
-        });
-        if (cache && method === "GET") {
-          const cacheOptions = cacheProps ? cacheProps : __spreadProps$2(__spreadValues$3({}, objectRemoveEmpty({
-            headers,
-            withCredentials,
-            responseType,
-            baseUrl: this.options.baseUrl,
-            userId: (_b = this.user) == null ? void 0 : _b.id
-          })), {
-            params
-          });
-          return this.cache.add(
-            cacheName || url,
-            createPromise,
-            cacheOptions,
-            false
-          );
-        }
-        return createPromise();
-      });
-    }
     // -------------------------------------------------------------------------
     // Resource Methods
     // -------------------------------------------------------------------------
@@ -1929,78 +2617,7 @@ var Geocoder = (function (exports) {
     deleteResource(resource) {
       return this.resources.delete(resource);
     }
-    /**
-     * @internal
-     */
-    _loadData(url, options) {
-      options.responseType = options.responseType || "json";
-      return new Promise((resolve, reject) => {
-        var _a;
-        if (this.user) {
-          options = options || {};
-          options.headers = __spreadValues$3(__spreadValues$3({}, this.getAuthorizationHeaders()), options.headers);
-        }
-        if (this.requestTransform) {
-          const [transUrl, transOptions] = this.requestTransform(url, options);
-          url = transUrl;
-          options = transOptions;
-        }
-        let runOnAbort = void 0;
-        loadData(url, resolve, options, reject, (handler) => {
-          runOnAbort = handler;
-        });
-        (_a = options.signal) == null ? void 0 : _a.addEventListener("abort", () => {
-          if (runOnAbort !== void 0) {
-            runOnAbort();
-          }
-          reject(new AbortError());
-        });
-      }).catch((httpError) => {
-        if (httpError.name !== "AbortError") {
-          {
-            console.warn("DEV WARN", httpError);
-          }
-          const er = this._handleHttpError(httpError);
-          if (er) {
-            throw er;
-          }
-        }
-        throw httpError;
-      });
-    }
-    _login(credentials, options) {
-      return __async$2(this, null, function* () {
-        try {
-          const data = yield this.getUserInfo(credentials, options);
-          this.user = data;
-          this.emitter.emit("login", data);
-          return data;
-        } catch (er) {
-          this.emitter.emit("login:error", er);
-          throw er;
-        }
-      });
-    }
-    _cleanActiveRequest(requestId) {
-      delete this.activeRequests[requestId];
-    }
-    _handleHttpError(er) {
-      if (er) {
-        if (er instanceof NgwError) {
-          if (er.exception === "nextgisweb.resource.exception.ResourceNotFound") {
-            throw new ResourceNotFoundError(er);
-          } else if (er.exception === "nextgisweb.core.exception.InsufficientPermissions") {
-            throw new InsufficientPermissionsError(er);
-          }
-        }
-      }
-      return er;
-    }
   }
-  __publicField$2(NgwConnector, "errors", {
-    NgwError,
-    ResourceNotFoundError
-  });
 
   function reEscape(s) {
     return s.replace(/[-/\\^$*+?.()|[\]{}]/g, "\\$&");
@@ -2072,6 +2689,10 @@ var Geocoder = (function (exports) {
     return logic === "any" ? filters_.some(filterFunction) : filters_.every(filterFunction);
   }
 
+  const config = {
+    defaultRequestLimit: 7e3
+  };
+
   var __defProp$3 = Object.defineProperty;
   var __defProps$1 = Object.defineProperties;
   var __getOwnPropDescs$1 = Object.getOwnPropertyDescriptors;
@@ -2117,15 +2738,12 @@ var Geocoder = (function (exports) {
   };
   function updateItemRequestParam(params, options) {
     const { extensions, geom, fields, srs, ilike, like } = options;
-    const extensionsStr = extensions ? extensions.join(",") : "";
-    if (extensionsStr !== "*") {
-      params.extensions = extensionsStr;
-    }
-    if (fields !== void 0) {
-      params.fields = Array.isArray(fields) ? fields.join(",") : "";
+    params.extensions = extensions ? extensions : [];
+    if (fields) {
+      params.fields = fields;
     }
     if (geom !== void 0) {
-      params.geom = geom ? "yes" : "no";
+      params.geom = geom;
       if (!geom) {
         delete params.srs;
         delete params.geom_format;
@@ -2140,6 +2758,15 @@ var Geocoder = (function (exports) {
       params.srs = srs;
     }
   }
+  function paramListToQuery(paramList) {
+    return paramList.reduce(
+      (acc, [key, value]) => {
+        acc[key] = value;
+        return acc;
+      },
+      {}
+    );
+  }
   function createFeatureFieldFilterQueries(opt) {
     return __async$1(this, null, function* () {
       const queries = getQueries(opt);
@@ -2240,6 +2867,7 @@ var Geocoder = (function (exports) {
     const params = __spreadValues$2({}, FEATURE_REQUEST_PARAMS);
     const {
       limit,
+      query,
       cache,
       signal,
       offset,
@@ -2250,12 +2878,10 @@ var Geocoder = (function (exports) {
       intersects,
       resourceId
     } = options;
-    if (limit) {
-      if (limit !== Number.POSITIVE_INFINITY) {
-        params.limit = limit;
-      }
+    if (limit && limit !== Number.POSITIVE_INFINITY) {
+      params.limit = limit;
     } else {
-      params.limit = 7e3;
+      params.limit = config.defaultRequestLimit;
     }
     if (offset) {
       params.offset = offset;
@@ -2274,16 +2900,9 @@ var Geocoder = (function (exports) {
       params.intersects = intersects;
     }
     if (paramList) {
-      params.paramList = paramList;
-    }
-    const reqParams = __spreadValues$2({
-      id: resourceId
-    }, params);
-    return connector.get(
-      "feature_layer.feature.collection",
-      { cache, signal },
-      reqParams
-    );
+      Object.assign(params, paramListToQuery(paramList));
+    }
+    return connector.route("feature_layer.feature.collection", { id: Number(resourceId) }).get({ query: __spreadValues$2(__spreadValues$2({}, params), query), cache, signal });
   }
 
   function prepareNgwFieldsToPropertiesFilter(fields) {
@@ -2436,7 +3055,7 @@ var Geocoder = (function (exports) {
           "The `searchUrl` of `connectorOptions.baseUrl` are required"
         );
       }
-      this.connector = options.connector || new NgwConnector(__spreadValues({
+      this.connector = options.connector || new NgwConnectorExtended(__spreadValues({
         baseUrl: this.searchUrl
       }, options.connectorOptions));
       this.searchResources = options.searchResources;
@@ -2485,7 +3104,7 @@ var Geocoder = (function (exports) {
               yield item;
             }
           } catch (er) {
-            if (er && "name" in er && er.name !== "CancelError") {
+            if (er && "name" in er && er.name !== "AbortError") {
               console.warn(er);
             }
           }
@@ -2494,14 +3113,10 @@ var Geocoder = (function (exports) {
     }
     result(item) {
       const signal = this._makeSignal();
-      const req = this.connector.get(
-        "feature_layer.feature.item_extent",
-        { signal },
-        {
-          id: item.resourceId,
-          fid: item.featureId
-        }
-      ).then((x) => {
+      const req = this.connector.route("feature_layer.feature.item_extent", {
+        id: item.resourceId,
+        fid: item.featureId
+      }).get({ signal }).then((x) => {
         const e = x.extent;
         return {
           text: item.text,
@@ -2588,56 +3203,69 @@ var Geocoder = (function (exports) {
   };
   class NominatimProvider extends BaseProvider {
     constructor(options) {
-      super(options);
+      super();
+      this.options = options;
       __publicField(this, "searchUrl", "https://nominatim.openstreetmap.org");
-      __publicField(this, "_abort", []);
+      __publicField(this, "_abortControllers", []);
       if (options && options.searchUrl) {
         this.searchUrl = options.searchUrl;
       }
     }
     abort() {
-      this._abort.forEach((x) => x());
-      this._abort = [];
+      this._abortControllers.forEach((controller) => {
+        controller.abort();
+      });
+      this._abortControllers = [];
     }
     search(val) {
       return __asyncGenerator(this, null, function* () {
-        const url = fixUrlStr(
-          // `${this.baseUrl}/search?format=geojson&polygon_geojson=1${window.locale === 'ru' ? '&accept-language=ru-RU,en-US' : ''}&q=${val}`
-          `${this.searchUrl}/search?format=geojson&polygon_geojson=1&q=${val}`
-        );
-        const request = new Promise((resolve, reject) => {
-          const xhr = new XMLHttpRequest();
-          xhr.open("GET", url, true);
-          xhr.onload = () => {
-            try {
-              const geojson = JSON.parse(xhr.responseText);
-              const features = geojson.features.map((x) => {
-                return {
-                  geom: x,
-                  extent: x.bbox,
-                  text: x.properties && x.properties.display_name,
-                  query: val
-                };
-              });
-              resolve(features);
-            } catch (er) {
-              reject(er);
-            }
-          };
-          xhr.onerror = (er) => {
-            reject(er);
-          };
-          this._abort.push(xhr.abort);
-          xhr.send();
-        }).catch((er) => {
-          if (er.name === "CancelError") ;
-          throw er;
+        var _a, _b, _c, _d, _e, _f, _g;
+        const params = new URLSearchParams({
+          format: "geojson",
+          polygon_geojson: "1",
+          q: val,
+          limit: ((_b = (_a = this.options) == null ? void 0 : _a.limit) == null ? void 0 : _b.toString()) || "10"
         });
-        const items = yield new __await(request);
-        if (items) {
-          for (const i of items) {
-            i.result = () => this.result(i);
-            yield i;
+        if ((_c = this.options) == null ? void 0 : _c.countrycodes) {
+          params.append("countrycodes", this.options.countrycodes);
+        }
+        if ((_d = this.options) == null ? void 0 : _d.addressdetails) {
+          params.append("addressdetails", "1");
+        }
+        if ((_e = this.options) == null ? void 0 : _e.language) {
+          params.append("accept-language", this.options.language);
+        }
+        if ((_f = this.options) == null ? void 0 : _f.bounded) {
+          params.append("bounded", "1");
+        }
+        if ((_g = this.options) == null ? void 0 : _g.viewbox) {
+          const [minLon, minLat, maxLon, maxLat] = this.options.viewbox;
+          params.append("viewbox", `${minLon},${minLat},${maxLon},${maxLat}`);
+        }
+        const url = fixUrlStr(`${this.searchUrl}/search?${params.toString()}`);
+        const controller = new AbortController();
+        this._abortControllers.push(controller);
+        try {
+          const response = yield new __await(fetch(url, { signal: controller.signal }));
+          if (!response.ok) {
+            throw new Error(`Network response was not ok: ${response.statusText}`);
+          }
+          const geojson = yield new __await(response.json());
+          const features = geojson.features.map((x) => {
+            return {
+              geom: x,
+              extent: x.bbox,
+              text: x.properties && x.properties.display_name,
+              query: val
+            };
+          });
+          for (const item of features) {
+            item.result = () => this.result(item);
+            yield item;
+          }
+        } catch (error) {
+          if (error.name === "AbortError") ; else {
+            throw error;
           }
         }
       });
@@ -2651,41 +3279,41 @@ var Geocoder = (function (exports) {
     }
     reverse(coordinates) {
       return __asyncGenerator(this, null, function* () {
+        var _a, _b;
         const [lng, lat] = coordinates;
-        const url = fixUrlStr(
-          `${this.searchUrl}/reverse?format=geojson&lat=${lat}&lon=${lng}`
-        );
-        const request = new Promise((resolve, reject) => {
-          const xhr = new XMLHttpRequest();
-          xhr.open("GET", url, true);
-          xhr.onload = () => {
-            try {
-              const geojson = JSON.parse(xhr.responseText);
-              const feature = geojson.features[0];
-              const result = {
-                geom: feature,
-                extent: feature.bbox,
-                text: feature.properties && feature.properties.display_name,
-                query: `${lat}, ${lng}`
-              };
-              resolve(result);
-            } catch (er) {
-              reject(er);
-            }
-          };
-          xhr.onerror = (er) => {
-            reject(er);
-          };
-          this._abort.push(xhr.abort);
-          xhr.send();
-        }).catch((er) => {
-          if (er.name === "CancelError") ;
-          throw er;
+        const params = new URLSearchParams({
+          format: "geojson",
+          lat: lat.toString(),
+          lon: lng.toString()
         });
-        const item = yield new __await(request);
-        if (item) {
+        if ((_a = this.options) == null ? void 0 : _a.addressdetails) {
+          params.append("addressdetails", "1");
+        }
+        if ((_b = this.options) == null ? void 0 : _b.language) {
+          params.append("accept-language", this.options.language);
+        }
+        const url = fixUrlStr(`${this.searchUrl}/reverse?${params.toString()}`);
+        const controller = new AbortController();
+        this._abortControllers.push(controller);
+        try {
+          const response = yield new __await(fetch(url, { signal: controller.signal }));
+          if (!response.ok) {
+            throw new Error(`Network response was not ok: ${response.statusText}`);
+          }
+          const geojson = yield new __await(response.json());
+          const feature = geojson.features[0];
+          const item = {
+            geom: feature,
+            extent: feature.bbox,
+            text: feature.properties && feature.properties.display_name,
+            query: `${lat}, ${lng}`
+          };
           item.result = () => this.result(item);
           yield item;
+        } catch (error) {
+          if (error.name === "AbortError") ; else {
+            throw error;
+          }
         }
       });
     }