@nextgis/ngw-connector 3.0.0-alpha.4 → 3.0.0-alpha.5

package/lib/ngw-connector.cjs.js

@@ -1,13 +1,13 @@
-/** Bundle of @nextgis/ngw-connector; version: 3.0.0-alpha.4; author: NextGIS */
+/** Bundle of @nextgis/ngw-connector; version: 3.0.0-alpha.5; author: NextGIS */
 'use strict';
 
+var utils = require('@nextgis/utils');
 var events = require('events');
 var Cache = require('@nextgis/cache');
-var utils = require('@nextgis/utils');
 
 var pkg = {
 	name: "@nextgis/ngw-connector",
-	version: "3.0.0-alpha.4",
+	version: "3.0.0-alpha.5",
 	_priority: 12,
 	description: "A lightweight HTTP client optimized for use with NextGIS Web API",
 	main: "index.js",
@@ -16,15 +16,15 @@ var pkg = {
 	jsdelivr: "lib/ngw-connector.global.prod.js",
 	types: "lib/index.d.ts",
 	dependencies: {
-		"@nextgis/cache": "^3.0.0-alpha.4",
-		"@nextgis/cancelable-promise": "^3.0.0-alpha.3",
-		"@nextgis/utils": "^3.0.0-alpha.4",
+		"@nextgis/cache": "^3.0.0-alpha.5",
+		"@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.3"
+		"@nextgis/build-tools": "^3.0.0-alpha.5"
 	},
 	scripts: {
 		clean: "rimraf ./lib",
@@ -58,403 +58,411 @@ var pkg = {
 		type: "git",
 		url: "git://github.com/nextgis/nextgis_frontend.git"
 	},
+	engines: {
+		node: ">=18.20.4"
+	},
 	gitHead: "edc68033f914f6c95c4125b9738bba6d36e990b4"
 };
 
-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$4 = (obj, key, value) => __defNormalProp$4(obj, typeof key !== "symbol" ? key + "" : key, value);
+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 utils.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$6 = Object.defineProperty;
+var __defNormalProp$6 = (obj, key, value) => key in obj ? __defProp$6(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$6 = (obj, key, value) => __defNormalProp$6(obj, typeof key !== "symbol" ? key + "" : key, value);
 class NgwError extends Error {
   constructor(er) {
     super();
-    __publicField$4(this, "name", "NgwError");
-    __publicField$4(this, "title");
-    __publicField$4(this, "message");
-    __publicField$4(this, "detail");
-    __publicField$4(this, "exception");
-    __publicField$4(this, "status_code");
-    __publicField$4(this, "data");
-    __publicField$4(this, "guru_meditation");
+    __publicField$6(this, "name", "NgwError");
+    __publicField$6(this, "title");
+    __publicField$6(this, "message");
+    __publicField$6(this, "detail");
+    __publicField$6(this, "exception");
+    __publicField$6(this, "status_code");
+    __publicField$6(this, "data");
+    __publicField$6(this, "guru_meditation");
     Object.assign(this, er);
     Object.setPrototypeOf(this, NgwError.prototype);
   }
 }
 
-var __defProp$3 = Object.defineProperty;
-var __defNormalProp$3 = (obj, key, value) => key in obj ? __defProp$3(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField$3 = (obj, key, value) => __defNormalProp$3(obj, typeof key !== "symbol" ? key + "" : key, value);
+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$5 = (obj, key, value) => __defNormalProp$5(obj, typeof key !== "symbol" ? key + "" : key, value);
+class InsufficientPermissionsError extends NgwError {
+  constructor(obj) {
+    super(obj);
+    __publicField$5(this, "name", "InsufficientPermissionsError");
+    __publicField$5(this, "exception", "nextgisweb.core.exception.InsufficientPermissions");
+    Object.setPrototypeOf(this, InsufficientPermissionsError.prototype);
+  }
+}
+
+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$4 = (obj, key, value) => __defNormalProp$4(obj, typeof key !== "symbol" ? key + "" : key, value);
 class ResourceNotFoundError extends NgwError {
   constructor(obj) {
     super(obj);
-    __publicField$3(this, "name", "ResourceNotFoundError");
-    __publicField$3(this, "exception", "nextgisweb.resource.exception.ResourceNotFound");
+    __publicField$4(this, "name", "ResourceNotFoundError");
+    __publicField$4(this, "exception", "nextgisweb.resource.exception.ResourceNotFound");
     Object.setPrototypeOf(this, ResourceNotFoundError.prototype);
   }
 }
 
-function isObject(val) {
-  return Object.prototype.toString.call(val) === "[object Object]";
+var __defProp$3 = Object.defineProperty;
+var __defNormalProp$3 = (obj, key, value) => key in obj ? __defProp$3(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$3 = (obj, key, value) => __defNormalProp$3(obj, typeof key !== "symbol" ? key + "" : key, value);
+class BaseAPIError extends Error {
+  constructor(message) {
+    super(message || "Something went wrong.");
+    __publicField$3(this, "title");
+    this.name = "BaseAPIError";
+    this.title = "Unknown API error";
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, BaseAPIError);
+    }
+  }
 }
-
-function resourceCompare(res1, res2) {
-  return utils.objectDeepEqual(res1, res2);
+class NetworksResponseError extends BaseAPIError {
+  // prettier-ignore
+  constructor(message) {
+    super(message || "There is no response from the server or problem connecting to server.");
+    __publicField$3(this, "detail");
+    this.title = "Network error";
+    this.detail = "Check network connectivity and try again later.";
+  }
 }
-
-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 (utils.defined(value)) {
-        query[prefix + key] = value;
-      }
+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$3(this, "detail");
+    __publicField$3(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$3(this, "title");
+    __publicField$3(this, "data");
+    this.name = "LunkwillError";
+    this.title = "Long-running request error";
+    this.data = data;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, LunkwillError);
     }
   }
-  return query;
+}
+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$2 = Object.defineProperty;
-var __defNormalProp$2 = (obj, key, value) => key in obj ? __defProp$2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField$2 = (obj, key, value) => __defNormalProp$2(obj, typeof key !== "symbol" ? key + "" : key, value);
-class ResourcesControl {
-  constructor({
-    connector,
-    cacheId
-  }) {
-    __publicField$2(this, "cache");
-    __publicField$2(this, "connector");
-    this.connector = connector;
-    this.cache = new Cache({ namespace: cacheId });
+function lunkwillCheckResponse(lwResp) {
+  const ct = lwResp.headers.get("content-type");
+  return ct !== void 0 && ct !== null && ct.includes("application/vnd.lunkwill.request-summary+json");
+}
+async function responseJson(response) {
+  try {
+    return response.json();
+  } catch (e) {
+    throw new Error();
   }
-  // -------------------------------------------------------------------------
-  // 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 = { ...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;
-        }
-      }
+}
+async function lunkwillResponseUrl(lwResp) {
+  const lwData = await 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) {
+    await sleep(failed ? retry : delay);
+    failed = false;
+    let lwResp2;
+    let lwData2;
+    try {
+      lwResp2 = await fetch(sum, { credentials: "same-origin" });
+      lwData2 = await lwResp2.json();
+    } catch (e) {
+      failed = true;
+      continue;
     }
-    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);
+    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);
     }
-    return Promise.resolve(void 0);
   }
-  getOneOrFail(resource, requestOptions) {
-    return this.getOne(resource, requestOptions).then((res) => {
-      if (res) {
-        return res;
-      }
-      throw new ResourceNotFoundError();
-    });
+  return res;
+}
+async function lunkwillFetch(lwRespUrl) {
+  try {
+    return await window.fetch(lwRespUrl, { credentials: "same-origin" });
+  } catch (e) {
+    throw new NetworksResponseError();
   }
-  /**
-   * 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);
   }
-  getMany(resource, requestOptions) {
-    return this._resourceCacheFilter(resource).then((items) => {
-      if (!items.length) {
-        const query = {};
-        if (resource.keyname) {
-          query.keyname = resource.keyname;
-        } else {
-          Object.assign(query, resourceToQuery(resource));
-        }
-        return this.connector.get("resource.search", requestOptions, {
-          serialization: "full",
-          ...query
-        }).then((resources) => {
-          if ((requestOptions == null ? void 0 : requestOptions.cache) && resources) {
-            for (const x of resources) {
-              this.cache.add("resource.item", Promise.resolve(x), {
-                id: x.resource.id
-              });
-            }
-          }
-          return resources;
-        });
-      }
-      return items;
-    });
+  return path + urlParams;
+}
+async function request(path, options, cacheEngine) {
+  var _a;
+  const defaults = {
+    method: "GET",
+    credentials: "same-origin",
+    headers: {}
+  };
+  const {
+    withCredentials,
+    responseType,
+    cacheProps,
+    cacheName,
+    lunkwill,
+    cache,
+    query,
+    json,
+    ...opt
+  } = {
+    ...defaults,
+    ...options
+  };
+  if (withCredentials) {
+    opt.credentials = "include";
   }
-  getParent(resource, requestOptions) {
-    return this.getOne(resource, requestOptions).then((child) => {
-      if (child) {
-        return this.getOne(child.resource.parent.id, requestOptions);
-      }
-      return Promise.resolve(void 0);
-    });
+  let useLunkwill = false;
+  if (lunkwill !== void 0) {
+    lunkwill.toHeaders(opt.headers || {});
+    useLunkwill = true;
   }
-  getChildrenOf(resource, requestOptions) {
-    return this.getIdOrFail(resource).then(
-      (parent) => this._getChildrenOf(parent, requestOptions)
-    );
+  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;
   }
-  update(resource, data) {
-    return this.getId(resource).then((id) => {
-      if (id !== void 0) {
-        return this.connector.put("resource.item", { data }, { id });
+  const url = generateUrl(path, query);
+  const makeRequest = async () => {
+    let response;
+    try {
+      response = await fetch(url, opt);
+    } catch (e) {
+      if (e.name === "AbortError") {
+        throw e;
       }
-    });
-  }
-  /**
-   * Fast way to delete resource from NGW and clean cache.
-   * @param resource - Resource definition
-   */
-  delete(resource) {
-    return this.getId(resource).then((id) => {
-      if (id !== void 0) {
-        return this.connector.delete("resource.item", null, { id }).then(() => {
-          this._cleanResourceItemCache(id);
-          return void 0;
-        });
+      throw new NetworksResponseError();
+    }
+    if (useLunkwill && lunkwillCheckResponse(response)) {
+      const lwRespUrl = await lunkwillResponseUrl(response);
+      if (lunkwillReturnUrl) {
+        return lwRespUrl;
       }
-    });
-  }
-  _getChildrenOf(parent, requestOptions, _items = []) {
-    return this.connector.get("resource.collection", requestOptions, {
-      parent
-    }).then((items) => {
-      const recursivePromises = [];
-      for (const item of items) {
-        if (requestOptions == null ? void 0 : requestOptions.cache) {
-          this.cache.add("resource.item", Promise.resolve(item), {
-            id: item.resource.id
-          });
-        }
-        _items.push(item);
-        if ((requestOptions == null ? void 0 : requestOptions.recursive) && item.resource.children) {
-          recursivePromises.push(
-            this._getChildrenOf(item.resource.id, requestOptions, _items)
-          );
-        }
-      }
-      if (recursivePromises.length) {
-        return Promise.all(recursivePromises).then(() => {
-          return _items;
-        });
-      }
-      return _items;
-    });
-  }
-  async _cleanResourceItemCache(id) {
-    var _a;
-    const all = this.cache.all();
-    const toDelete = [];
-    for (const c of all) {
-      const cid = (_a = c.props) == null ? void 0 : _a.id;
-      if (["resource.item", "resource"].includes(c.key) && cid !== void 0) {
-        if (typeof cid === "number") {
-          if (cid === id) {
-            toDelete.push(c);
-          }
-        } else {
-          const rid = await this.getId(cid);
-          if (rid === id) {
-            toDelete.push(c);
-          }
-        }
-      }
-    }
-    for (const d of toDelete) {
-      this.cache.delete(d);
-    }
-  }
-  _fetchResourceById(id, requestOptions) {
-    return this.connector.get("resource.item", requestOptions, { id });
-  }
-  _fetchResourceBy(resource, requestOptions) {
-    return this.getMany(resource, requestOptions).then((resources) => {
-      return resources[0];
-    });
-  }
-  _resourceCacheFilter(resource) {
-    return Promise.all(this.cache.matchAll("resource.item")).then(
-      (resources) => {
-        const items = [];
-        resources.filter((x) => {
-          if (x) {
-            if (resource.keyname && x.resource.keyname) {
-              return resource.keyname === x.resource.keyname;
-            }
-            if (utils.defined(resource.id) && utils.defined(x.resource.id)) {
-              return resource.id === x.resource.id;
-            }
-            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 utils.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$1 = Object.defineProperty;
-var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField$1 = (obj, key, value) => __defNormalProp$1(obj, typeof key !== "symbol" ? key + "" : key, value);
-class InsufficientPermissionsError extends NgwError {
-  constructor(obj) {
-    super(obj);
-    __publicField$1(this, "name", "InsufficientPermissionsError");
-    __publicField$1(this, "exception", "nextgisweb.core.exception.InsufficientPermissions");
-    Object.setPrototypeOf(this, InsufficientPermissionsError.prototype);
+      response = await 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 = await response.blob();
+      } else if (respJSON) {
+        body = await 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 && cache && ((_a = opt.method) == null ? void 0 : _a.toUpperCase()) === "GET") {
+    const cacheOptions = cacheProps ? cacheProps : {
+      ...utils.objectRemoveEmpty({
+        withCredentials,
+        responseType
+      })
+    };
+    return cacheEngine.add(cacheName || url, makeRequest, cacheOptions, false);
   }
+  return makeRequest();
 }
 
-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);
+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)!");
     }
-    return value;
-  });
-}
-
-async function apiRequest(opt) {
-  const { params, name, connector, requestOptions } = opt;
-  const apiItems = await connector.connect();
-  let apiItem = apiItems && apiItems[name];
-  if (apiItem) {
-    apiItem = [...apiItem];
-    let url = apiItem.shift();
-    if (apiItem.length) {
-      const replaceParams = {};
-      for (let fry = 0; fry < apiItem.length; fry++) {
-        const arg = apiItem[fry];
-        replaceParams[fry] = `{${arg}}`;
-        if (params[arg] === void 0) {
-          throw new Error(`\`${arg}\` URL API argument is not specified`);
-        }
-      }
-      if (url) {
-        url = template(url, replaceParams);
-      }
+    sub = [];
+    for (const [p, v] of Object.entries(first)) {
+      sub[params.indexOf(p)] = String(v);
     }
-    if (params) {
-      const paramArray = [];
-      const paramList = params.paramList;
-      if (Array.isArray(paramList)) {
-        paramList.forEach(([key, value]) => {
-          paramArray.push(`${key}=${value}`);
-        });
-      }
-      for (const p in params) {
-        if (apiItem.indexOf(p) === -1) {
-          paramArray.push(`${p}=${params[p]}`);
-        }
-      }
-      if (paramArray.length) {
-        url = `${url}?${paramArray.join("&")}`;
+  } else {
+    sub = rest.map((v) => String(v));
+  }
+  return utils.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: async (opt) => {
+      var _a;
+      const routeData = await connector.connect();
+      const template = routeURL(
+        name,
+        (_a = connector.options.baseUrl) != null ? _a : "",
+        routeData,
+        ...rest
+      );
+      return generateUrl(template, opt == null ? void 0 : opt.query);
     }
-    if (url) {
-      return connector.makeQuery(url, params, {
-        cacheName: name,
-        ...requestOptions
+  };
+  const methods = ["get", "post", "put", "delete", "patch"];
+  for (const method of methods) {
+    const methodResp = async (requestOptions) => {
+      var _a;
+      const { headers: optHeaders, ...restOpt } = requestOptions || {};
+      const routeData = await connector.connect();
+      const template = routeURL(
+        name,
+        (_a = connector.options.baseUrl) != null ? _a : "",
+        routeData,
+        ...rest
+      );
+      const headers = utils.objectRemoveEmpty({
+        ...connector.getAuthorizationHeaders(),
+        ...optHeaders != null ? optHeaders : {}
       });
-    } else {
-      throw new Error("Request URL is not set");
-    }
-  } else {
-    return void 0;
+      return request(
+        template,
+        {
+          headers,
+          ...restOpt,
+          method
+        },
+        connector.cache
+      );
+    };
+    result[method] = methodResp;
   }
+  return result;
 }
 
 function isError(error) {
@@ -464,6 +472,10 @@ function isError(error) {
   return false;
 }
 
+function isObject(val) {
+  return Object.prototype.toString.call(val) === "[object Object]";
+}
+
 let loadData;
 {
   const url = require("url");
@@ -585,32 +597,44 @@ let loadData;
   };
 }
 
-var __defProp = Object.defineProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+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$2 = Object.defineProperty;
+var __defNormalProp$2 = (obj, key, value) => key in obj ? __defProp$2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$2 = (obj, key, value) => __defNormalProp$2(obj, typeof key !== "symbol" ? key + "" : key, value);
 let ID = 0;
 let REQUEST_ID = 0;
 class NgwConnector {
   constructor(options) {
     this.options = options;
-    __publicField(this, "id", ID++);
-    __publicField(this, "emitter", new events.EventEmitter());
-    __publicField(this, "user");
-    __publicField(this, "resources");
-    __publicField(this, "cache");
-    __publicField(this, "withCredentials");
-    __publicField(this, "client", `NextGIS-NGW-Connector/${pkg.version}`);
-    __publicField(this, "routeStr", "/api/component/pyramid/route");
-    __publicField(this, "activeRequests", {});
-    __publicField(this, "requestTransform");
+    __publicField$2(this, "id", ID++);
+    __publicField$2(this, "emitter", new events.EventEmitter());
+    __publicField$2(this, "user");
+    __publicField$2(this, "cache");
+    __publicField$2(this, "withCredentials");
+    __publicField$2(this, "client", `NextGIS-NGW-Connector/${pkg.version}`);
+    __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 {
-      const { route, requestTransform, withCredentials } = this.options;
-      if (route) {
-        this.routeStr = route;
+      const { route: route2, requestTransform, withCredentials } = this.options;
+      if (route2) {
+        this.routeStr = route2;
       }
       if (requestTransform) {
         this.requestTransform = requestTransform;
@@ -618,10 +642,6 @@ class NgwConnector {
       if (withCredentials !== void 0) {
         this.withCredentials = withCredentials;
       }
-      this.resources = new ResourcesControl({
-        connector: this,
-        cacheId: options.cacheId
-      });
       addConnector(this);
     }
   }
@@ -633,7 +653,6 @@ class NgwConnector {
    */
   clearCache() {
     this.cache.clean();
-    this.resources.cache.clean();
   }
   setRequestTransform(requestTransform) {
     this.requestTransform = requestTransform;
@@ -655,7 +674,7 @@ class NgwConnector {
    * Can be used to check connection.
    * @example
    * ```javascript
-   * const connector = new NgwConnector({baseUrl: 'https://demo.nextgis.com'});
+   * const connector = new NgwConnector({ baseUrl: 'https://demo.nextgis.com' });
    * connector.connect()
    *   .then(() => console.log('Ok'))
    *   .catch((er) => console.log('Connection problem', er));
@@ -669,88 +688,557 @@ class NgwConnector {
         await this._login({ login, password });
       }
     }
-    const routeUrl = `${this.routeStr}?client=${this.client}`;
-    return await this.makeQuery(
-      routeUrl,
-      {},
-      {
-        cacheName: "route",
-        cache: true,
-        cacheProps: {
-          id: this.id,
-          auth,
-          baseUrl: this.options.baseUrl
+    const routeUrl = `${this.routeStr}?client=${this.client}`;
+    return await 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");
+  }
+  async getUserInfo(credentials, options) {
+    if (this.user && this.user.id) {
+      return this.user;
+    }
+    if (credentials) {
+      this.options.auth = credentials;
+    }
+    const options_ = {
+      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 Buffer.from(encodedStr).toString("base64");
+      }
+    }
+  }
+  /** Stop all api requests */
+  abort() {
+    for (const abortController of Object.values(this.activeRequests)) {
+      abortController.abort();
+    }
+    this.activeRequests = {};
+  }
+  getActiveApiRequests() {
+    return { ...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
+   */
+  async makeQuery(url, params, options = {}) {
+    var _a;
+    url = (this.options.baseUrl ? this.options.baseUrl : "") + url;
+    if (!url) {
+      throw new Error("Empty `url` not allowed");
+    }
+    if (params) {
+      const { paramList, ...restParams } = params;
+      url = template(url, restParams);
+    }
+    url = encodeURI(utils.fixUrlStr(url));
+    options = { 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 () => {
+      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 : {
+        ...utils.objectRemoveEmpty({
+          headers,
+          withCredentials,
+          responseType,
+          baseUrl: this.options.baseUrl,
+          userId: (_a = this.user) == null ? void 0 : _a.id
+        }),
+        params
+      };
+      return this.cache.add(
+        cacheName || url,
+        createPromise,
+        cacheOptions,
+        false
+      );
+    }
+    return createPromise();
+  }
+  _loadData(url, options) {
+    options.responseType = options.responseType || "json";
+    return new Promise((resolve, reject) => {
+      var _a;
+      if (this.user) {
+        options = options || {};
+        options.headers = {
+          ...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;
+    });
+  }
+  async _login(credentials, options) {
+    try {
+      const data = await 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 resourceCompare(res1, res2) {
+  return utils.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 (utils.defined(value)) {
+        query[prefix + key] = value;
+      }
+    }
+  }
+  return query;
+}
+
+var __defProp$1 = Object.defineProperty;
+var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$1 = (obj, key, value) => __defNormalProp$1(obj, typeof key !== "symbol" ? key + "" : key, value);
+class ResourcesControl {
+  constructor({
+    connector,
+    cacheId
+  }) {
+    __publicField$1(this, "cache");
+    __publicField$1(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 = { ...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) => {
+      if (!items.length) {
+        const query = {};
+        if (resource.keyname) {
+          query.keyname = resource.keyname;
+        } else {
+          Object.assign(query, resourceToQuery(resource));
+        }
+        return this.connector.get("resource.search", requestOptions, {
+          serialization: "full",
+          ...query
+        }).then((resources) => {
+          if ((requestOptions == null ? void 0 : requestOptions.cache) && resources) {
+            for (const x of resources) {
+              this.cache.add("resource.item", Promise.resolve(x), {
+                id: x.resource.id
+              });
+            }
+          }
+          return resources;
+        });
+      }
+      return items;
+    });
+  }
+  getParent(resource, requestOptions) {
+    return this.getOne(resource, requestOptions).then((child) => {
+      if (child) {
+        return this.getOne(child.resource.parent.id, requestOptions);
+      }
+      return Promise.resolve(void 0);
+    });
+  }
+  getChildrenOf(resource, requestOptions) {
+    return this.getIdOrFail(resource).then(
+      (parent) => this._getChildrenOf(parent, requestOptions)
+    );
+  }
+  update(resource, data) {
+    return this.getId(resource).then((id) => {
+      if (id !== void 0) {
+        return this.connector.put("resource.item", { data }, { id });
+      }
+    });
+  }
+  /**
+   * Fast way to delete resource from NGW and clean cache.
+   * @param resource - Resource definition
+   */
+  delete(resource) {
+    return this.getId(resource).then((id) => {
+      if (id !== void 0) {
+        return this.connector.delete("resource.item", null, { id }).then(() => {
+          this._cleanResourceItemCache(id);
+          return void 0;
+        });
+      }
+    });
+  }
+  _getChildrenOf(parent, requestOptions, _items = []) {
+    return this.connector.get("resource.collection", requestOptions, {
+      parent
+    }).then((items) => {
+      const recursivePromises = [];
+      for (const item of items) {
+        if (requestOptions == null ? void 0 : requestOptions.cache) {
+          this.cache.add("resource.item", Promise.resolve(item), {
+            id: item.resource.id
+          });
+        }
+        _items.push(item);
+        if ((requestOptions == null ? void 0 : requestOptions.recursive) && item.resource.children) {
+          recursivePromises.push(
+            this._getChildrenOf(item.resource.id, requestOptions, _items)
+          );
+        }
+      }
+      if (recursivePromises.length) {
+        return Promise.all(recursivePromises).then(() => {
+          return _items;
+        });
+      }
+      return _items;
+    });
+  }
+  async _cleanResourceItemCache(id) {
+    var _a;
+    const all = this.cache.all();
+    const toDelete = [];
+    for (const c of all) {
+      const cid = (_a = c.props) == null ? void 0 : _a.id;
+      if (["resource.item", "resource"].includes(c.key) && cid !== void 0) {
+        if (typeof cid === "number") {
+          if (cid === id) {
+            toDelete.push(c);
+          }
+        } else {
+          const rid = await this.getId(cid);
+          if (rid === id) {
+            toDelete.push(c);
+          }
+        }
+      }
+    }
+    for (const d of toDelete) {
+      this.cache.delete(d);
+    }
+  }
+  _fetchResourceById(id, requestOptions) {
+    return this.connector.get("resource.item", requestOptions, { id });
+  }
+  _fetchResourceBy(resource, requestOptions) {
+    return this.getMany(resource, requestOptions).then((resources) => {
+      return resources[0];
+    });
+  }
+  _resourceCacheFilter(resource) {
+    return Promise.all(this.cache.matchAll("resource.item")).then(
+      (resources) => {
+        const items = [];
+        resources.filter((x) => {
+          if (x) {
+            if (resource.keyname && x.resource.keyname) {
+              return resource.keyname === x.resource.keyname;
+            }
+            if (utils.defined(resource.id) && utils.defined(x.resource.id)) {
+              return resource.id === x.resource.id;
+            }
+            return resourceCompare(resource, x.resource);
+          }
+        });
+        return items;
+      }
+    );
+  }
+}
+
+async function apiRequest(opt) {
+  const { params, name, connector, requestOptions } = opt;
+  const apiItems = await connector.connect();
+  let apiItem = apiItems && apiItems[name];
+  if (apiItem) {
+    apiItem = [...apiItem];
+    let url = apiItem.shift();
+    if (apiItem.length) {
+      const replaceParams = {};
+      for (let fry = 0; fry < apiItem.length; fry++) {
+        const arg = apiItem[fry];
+        replaceParams[fry] = `{${arg}}`;
+        if (params[arg] === void 0) {
+          throw new Error(`\`${arg}\` URL API argument is not specified`);
+        }
+      }
+      if (url) {
+        url = template(url, replaceParams);
+      }
+    }
+    if (params) {
+      const paramArray = [];
+      const paramList = params.paramList;
+      if (Array.isArray(paramList)) {
+        paramList.forEach(([key, value]) => {
+          paramArray.push(`${key}=${value}`);
+        });
+      }
+      for (const p in params) {
+        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");
-  }
-  async getUserInfo(credentials, options) {
-    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, {
+        cacheName: name,
+        ...requestOptions
+      });
+    } else {
+      throw new Error("Request URL is not set");
     }
-    const options_ = {
-      headers: this.getAuthorizationHeaders(credentials),
-      ...options
-    };
-    return this.makeQuery(
-      "/api/component/auth/current_user",
-      {},
-      options_
-    );
+  } else {
+    return void 0;
+  }
+}
+
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, key + "" , value);
+class NgwConnectorExtended extends NgwConnector {
+  constructor(options) {
+    super(options);
+    this.options = options;
+    __publicField(this, "resources");
+    this.resources = new ResourcesControl({
+      connector: this,
+      cacheId: options.cacheId
+    });
   }
   /**
-   * 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 encodedStr = [login, password].map(encodeURIComponent).join(":");
-      {
-        return Buffer.from(encodedStr).toString("base64");
-      }
-    }
-  }
-  /** Stop all api requests */
-  abort() {
-    for (const abortController of Object.values(this.activeRequests)) {
-      abortController.abort();
-    }
-    this.activeRequests = {};
-  }
-  getActiveApiRequests() {
-    return { ...this.activeRequests };
+  clearCache() {
+    super.clearCache();
+    this.resources.cache.clean();
   }
   /**
    * Send request to NGW api router.
@@ -869,74 +1357,6 @@ class NgwConnector {
       options
     );
   }
-  /**
-   * Send request to NGW.
-   * @param url - URL address to NGW
-   * @param params - Query params
-   * @param options - Request options
-   */
-  async makeQuery(url, params, options = {}) {
-    var _a;
-    url = (this.options.baseUrl ? this.options.baseUrl : "") + url;
-    if (!url) {
-      throw new Error("Empty `url` not allowed");
-    }
-    if (params) {
-      const { paramList, ...restParams } = params;
-      url = template(url, restParams);
-    }
-    url = encodeURI(utils.fixUrlStr(url));
-    options = { 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 () => {
-      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 : {
-        ...utils.objectRemoveEmpty({
-          headers,
-          withCredentials,
-          responseType,
-          baseUrl: this.options.baseUrl,
-          userId: (_a = this.user) == null ? void 0 : _a.id
-        }),
-        params
-      };
-      return this.cache.add(
-        cacheName || url,
-        createPromise,
-        cacheOptions,
-        false
-      );
-    }
-    return createPromise();
-  }
   // -------------------------------------------------------------------------
   // Resource Methods
   // -------------------------------------------------------------------------
@@ -1012,79 +1432,7 @@ class NgwConnector {
   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 = {
-          ...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;
-    });
-  }
-  async _login(credentials, options) {
-    try {
-      const data = await 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(NgwConnector, "errors", {
-  NgwError,
-  ResourceNotFoundError
-});
 
-module.exports = NgwConnector;
+module.exports = NgwConnectorExtended;
 //# sourceMappingURL=ngw-connector.cjs.js.map