@nextgis/ngw-connector/lib/ngw-connector.global.js

A lightweight HTTP client optimized for use with NextGIS Web API

/** Bundle of @nextgis/ngw-connector; version: 3.0.1; author: NextGIS */
var NgwConnector = (function () {
  'use strict';

  function defined(val) {
    return val !== void 0 && val !== null;
  }
  function full(val) {
    return typeof val === "string" ? !!val : defined(val);
  }

  function isEqual(a, b, o, p) {
    if (a instanceof Array) {
      if (!(b instanceof Array)) return false;
      return b.sort().join("") === a.sort().join("");
    } else if (a instanceof Date) {
      if (!(b instanceof Date)) return false;
      return "" + a === "" + b;
    } else if (a instanceof Function) {
      if (!(b instanceof Function)) return false;
    } else if (a instanceof Object) {
      if (!(b instanceof Object)) return false;
      if (a === o) {
        return b === p;
      } else {
        return objectDeepEqual(a, b);
      }
    }
    return a === b;
  }
  function objectDeepEqual(o, p) {
    const keysO = Object.keys(o).sort();
    const keysP = Object.keys(p).sort();
    if (keysO.length !== keysP.length) return false;
    if (keysO.join("") !== keysP.join("")) return false;
    for (let i = 0; i < keysO.length; i++) {
      const oVal = o[keysO[i]];
      const pVal = p[keysP[i]];
      if (!isEqual(oVal, pVal, o, p)) {
        return false;
      }
    }
    return true;
  }

  function objectRemoveEmpty(obj) {
    const newObj = {};
    Object.keys(obj).forEach((key) => {
      if (!(obj[key] instanceof Array) && obj[key] === Object(obj[key])) {
        newObj[key] = objectRemoveEmpty(obj[key]);
      } else if (obj[key] !== void 0) {
        newObj[key] = obj[key];
      }
    });
    return newObj;
  }

  function isObject$1(val) {
    return Object.prototype.toString.call(val) === "[object Object]";
  }

  function fixUrlStr(url) {
    return url.replace(/([^:]\/)\/+/g, "$1");
  }

  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$c = Object.defineProperty;
  var __getOwnPropSymbols$4 = Object.getOwnPropertySymbols;
  var __hasOwnProp$4 = Object.prototype.hasOwnProperty;
  var __propIsEnum$4 = Object.prototype.propertyIsEnumerable;
  var __defNormalProp$c = (obj, key, value) => key in obj ? __defProp$c(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$c(a, prop, b[prop]);
    if (__getOwnPropSymbols$4)
      for (var prop of __getOwnPropSymbols$4(b)) {
        if (__propIsEnum$4.call(b, prop))
          __defNormalProp$c(a, prop, b[prop]);
      }
    return a;
  };
  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());
    });
  };
  function apiRequest(opt) {
    return __async$4(this, null, function* () {
      const { params, name, connector, requestOptions } = opt;
      const apiItems = yield 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]}`);
            }
          }
          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$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$9 = (obj, key, value) => __defNormalProp$b(obj, typeof key !== "symbol" ? key + "" : key, value);
  const _Cache = class _Cache {
    constructor(options = {}) {
      __publicField$9(this, "cache", []);
      var _a;
      const namespace = (_a = options.namespace) != null ? _a : "default";
      if (_Cache.instance[namespace]) {
        return _Cache.instance[namespace];
      }
      _Cache.instance[namespace] = this;
      return this;
    }
    clean() {
      this.cache.length = 0;
    }
    all() {
      return this.cache;
    }
    /**
     * Caching only a non-empty value.
     *
     * Useful for get or create strategy
     * @example
     * ```javascript
     * const cache = new Cache();
     * const getItemFunc = () => fetch(url).then((data) => {
     *  return data.json(); // undefined
     * });
     * const item = await cache.addFull('foo', getItemFunc);
     * if (!item) {
     *   await createItem(); // 'New item'
     * }
     *
     * // somewhere else in the code
     * const item = await cache.addFull('foo', getItemFunc).then((resp) => {
     *   console.log(resp); // 'New item'
     * });
     * ```
     */
    addFull(key, valueToSet, 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;
        if (valueToSet instanceof Function) {
          value = valueToSet();
        } else {
          value = valueToSet;
        }
        const nonEmptyProps = props && JSON.parse(JSON.stringify(objectRemoveEmpty(props)));
        expirationTime = expirationTime ? Date.now() + expirationTime : void 0;
        const cacheItem = {
          key,
          value,
          props: nonEmptyProps,
          expirationTime
        };
        if (onlyFull && !full(value)) {
          return value;
        }
        this.cache.push(cacheItem);
        if (value instanceof Promise) {
          value.catch(() => {
            this.delete(key, props);
          });
          if (onlyFull) {
            value.then((x) => {
              if (!full(x)) {
                this.delete(key, props);
              }
              return x;
            });
          }
          return value;
        }
        return value;
      } else {
        return exist.value;
      }
    }
    match(key, props) {
      const cacheRecord = this._find(key, props);
      if (cacheRecord && 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);
      }
      return this.cache.map((x) => x.value);
    }
    delete(keyOrItem, props) {
      const itemsToDelete = typeof keyOrItem === "string" ? this.cache.filter((x) => this._filter(x, keyOrItem, props)) : [keyOrItem];
      for (const item of itemsToDelete) {
        const index = this.cache.indexOf(item);
        if (index !== -1) {
          this.cache.splice(index, 1);
        }
      }
    }
    _find(key, props) {
      return this.cache.find((x) => this._filter(x, key, props));
    }
    _filter(item, key, props) {
      if (item.key !== key) return false;
      if (!props) return true;
      const itemProps = item.props;
      return objectDeepEqual(itemProps || {}, objectRemoveEmpty(props));
    }
  };
  __publicField$9(_Cache, "instance", {});
  let Cache = _Cache;

  var domain;

  // This constructor is used to store event handlers. Instantiating this is
  // faster than explicitly calling `Object.create(null)` to get a "clean" empty
  // object (tested with v8 v4.9).
  function EventHandlers() {}
  EventHandlers.prototype = Object.create(null);

  function EventEmitter() {
    EventEmitter.init.call(this);
  }

  // nodejs oddity
  // require('events') === require('events').EventEmitter
  EventEmitter.EventEmitter = EventEmitter;

  EventEmitter.usingDomains = false;

  EventEmitter.prototype.domain = undefined;
  EventEmitter.prototype._events = undefined;
  EventEmitter.prototype._maxListeners = undefined;

  // By default EventEmitters will print a warning if more than 10 listeners are
  // added to it. This is a useful default which helps finding memory leaks.
  EventEmitter.defaultMaxListeners = 10;

  EventEmitter.init = function() {
    this.domain = null;
    if (EventEmitter.usingDomains) {
      // if there is an active domain, then attach to it.
      if (domain.active) ;
    }

    if (!this._events || this._events === Object.getPrototypeOf(this)._events) {
      this._events = new EventHandlers();
      this._eventsCount = 0;
    }

    this._maxListeners = this._maxListeners || undefined;
  };

  // Obviously not all Emitters should be limited to 10. This function allows
  // that to be increased. Set to zero for unlimited.
  EventEmitter.prototype.setMaxListeners = function setMaxListeners(n) {
    if (typeof n !== 'number' || n < 0 || isNaN(n))
      throw new TypeError('"n" argument must be a positive number');
    this._maxListeners = n;
    return this;
  };

  function $getMaxListeners(that) {
    if (that._maxListeners === undefined)
      return EventEmitter.defaultMaxListeners;
    return that._maxListeners;
  }

  EventEmitter.prototype.getMaxListeners = function getMaxListeners() {
    return $getMaxListeners(this);
  };

  // These standalone emit* functions are used to optimize calling of event
  // handlers for fast cases because emit() itself often has a variable number of
  // arguments and can be deoptimized because of that. These functions always have
  // the same number of arguments and thus do not get deoptimized, so the code
  // inside them can execute faster.
  function emitNone(handler, isFn, self) {
    if (isFn)
      handler.call(self);
    else {
      var len = handler.length;
      var listeners = arrayClone(handler, len);
      for (var i = 0; i < len; ++i)
        listeners[i].call(self);
    }
  }
  function emitOne(handler, isFn, self, arg1) {
    if (isFn)
      handler.call(self, arg1);
    else {
      var len = handler.length;
      var listeners = arrayClone(handler, len);
      for (var i = 0; i < len; ++i)
        listeners[i].call(self, arg1);
    }
  }
  function emitTwo(handler, isFn, self, arg1, arg2) {
    if (isFn)
      handler.call(self, arg1, arg2);
    else {
      var len = handler.length;
      var listeners = arrayClone(handler, len);
      for (var i = 0; i < len; ++i)
        listeners[i].call(self, arg1, arg2);
    }
  }
  function emitThree(handler, isFn, self, arg1, arg2, arg3) {
    if (isFn)
      handler.call(self, arg1, arg2, arg3);
    else {
      var len = handler.length;
      var listeners = arrayClone(handler, len);
      for (var i = 0; i < len; ++i)
        listeners[i].call(self, arg1, arg2, arg3);
    }
  }

  function emitMany(handler, isFn, self, args) {
    if (isFn)
      handler.apply(self, args);
    else {
      var len = handler.length;
      var listeners = arrayClone(handler, len);
      for (var i = 0; i < len; ++i)
        listeners[i].apply(self, args);
    }
  }

  EventEmitter.prototype.emit = function emit(type) {
    var er, handler, len, args, i, events, domain;
    var doError = (type === 'error');

    events = this._events;
    if (events)
      doError = (doError && events.error == null);
    else if (!doError)
      return false;

    domain = this.domain;

    // If there is no 'error' event listener then throw.
    if (doError) {
      er = arguments[1];
      if (domain) {
        if (!er)
          er = new Error('Uncaught, unspecified "error" event');
        er.domainEmitter = this;
        er.domain = domain;
        er.domainThrown = false;
        domain.emit('error', er);
      } else if (er instanceof Error) {
        throw er; // Unhandled 'error' event
      } else {
        // At least give some kind of context to the user
        var err = new Error('Uncaught, unspecified "error" event. (' + er + ')');
        err.context = er;
        throw err;
      }
      return false;
    }

    handler = events[type];

    if (!handler)
      return false;

    var isFn = typeof handler === 'function';
    len = arguments.length;
    switch (len) {
      // fast cases
      case 1:
        emitNone(handler, isFn, this);
        break;
      case 2:
        emitOne(handler, isFn, this, arguments[1]);
        break;
      case 3:
        emitTwo(handler, isFn, this, arguments[1], arguments[2]);
        break;
      case 4:
        emitThree(handler, isFn, this, arguments[1], arguments[2], arguments[3]);
        break;
      // slower
      default:
        args = new Array(len - 1);
        for (i = 1; i < len; i++)
          args[i - 1] = arguments[i];
        emitMany(handler, isFn, this, args);
    }

    return true;
  };

  function _addListener(target, type, listener, prepend) {
    var m;
    var events;
    var existing;

    if (typeof listener !== 'function')
      throw new TypeError('"listener" argument must be a function');

    events = target._events;
    if (!events) {
      events = target._events = new EventHandlers();
      target._eventsCount = 0;
    } else {
      // To avoid recursion in the case that type === "newListener"! Before
      // adding it to the listeners, first emit "newListener".
      if (events.newListener) {
        target.emit('newListener', type,
                    listener.listener ? listener.listener : listener);

        // Re-assign `events` because a newListener handler could have caused the
        // this._events to be assigned to a new object
        events = target._events;
      }
      existing = events[type];
    }

    if (!existing) {
      // Optimize the case of one listener. Don't need the extra array object.
      existing = events[type] = listener;
      ++target._eventsCount;
    } else {
      if (typeof existing === 'function') {
        // Adding the second element, need to change to array.
        existing = events[type] = prepend ? [listener, existing] :
                                            [existing, listener];
      } else {
        // If we've already got an array, just append.
        if (prepend) {
          existing.unshift(listener);
        } else {
          existing.push(listener);
        }
      }

      // Check for listener leak
      if (!existing.warned) {
        m = $getMaxListeners(target);
        if (m && m > 0 && existing.length > m) {
          existing.warned = true;
          var w = new Error('Possible EventEmitter memory leak detected. ' +
                              existing.length + ' ' + type + ' listeners added. ' +
                              'Use emitter.setMaxListeners() to increase limit');
          w.name = 'MaxListenersExceededWarning';
          w.emitter = target;
          w.type = type;
          w.count = existing.length;
          emitWarning(w);
        }
      }
    }

    return target;
  }
  function emitWarning(e) {
    typeof console.warn === 'function' ? console.warn(e) : console.log(e);
  }
  EventEmitter.prototype.addListener = function addListener(type, listener) {
    return _addListener(this, type, listener, false);
  };

  EventEmitter.prototype.on = EventEmitter.prototype.addListener;

  EventEmitter.prototype.prependListener =
      function prependListener(type, listener) {
        return _addListener(this, type, listener, true);
      };

  function _onceWrap(target, type, listener) {
    var fired = false;
    function g() {
      target.removeListener(type, g);
      if (!fired) {
        fired = true;
        listener.apply(target, arguments);
      }
    }
    g.listener = listener;
    return g;
  }

  EventEmitter.prototype.once = function once(type, listener) {
    if (typeof listener !== 'function')
      throw new TypeError('"listener" argument must be a function');
    this.on(type, _onceWrap(this, type, listener));
    return this;
  };

  EventEmitter.prototype.prependOnceListener =
      function prependOnceListener(type, listener) {
        if (typeof listener !== 'function')
          throw new TypeError('"listener" argument must be a function');
        this.prependListener(type, _onceWrap(this, type, listener));
        return this;
      };

  // emits a 'removeListener' event iff the listener was removed
  EventEmitter.prototype.removeListener =
      function removeListener(type, listener) {
        var list, events, position, i, originalListener;

        if (typeof listener !== 'function')
          throw new TypeError('"listener" argument must be a function');

        events = this._events;
        if (!events)
          return this;

        list = events[type];
        if (!list)
          return this;

        if (list === listener || (list.listener && list.listener === listener)) {
          if (--this._eventsCount === 0)
            this._events = new EventHandlers();
          else {
            delete events[type];
            if (events.removeListener)
              this.emit('removeListener', type, list.listener || listener);
          }
        } else if (typeof list !== 'function') {
          position = -1;

          for (i = list.length; i-- > 0;) {
            if (list[i] === listener ||
                (list[i].listener && list[i].listener === listener)) {
              originalListener = list[i].listener;
              position = i;
              break;
            }
          }

          if (position < 0)
            return this;

          if (list.length === 1) {
            list[0] = undefined;
            if (--this._eventsCount === 0) {
              this._events = new EventHandlers();
              return this;
            } else {
              delete events[type];
            }
          } else {
            spliceOne(list, position);
          }

          if (events.removeListener)
            this.emit('removeListener', type, originalListener || listener);
        }

        return this;
      };
      
  // Alias for removeListener added in NodeJS 10.0
  // https://nodejs.org/api/events.html#events_emitter_off_eventname_listener
  EventEmitter.prototype.off = function(type, listener){
      return this.removeListener(type, listener);
  };

  EventEmitter.prototype.removeAllListeners =
      function removeAllListeners(type) {
        var listeners, events;

        events = this._events;
        if (!events)
          return this;

        // not listening for removeListener, no need to emit
        if (!events.removeListener) {
          if (arguments.length === 0) {
            this._events = new EventHandlers();
            this._eventsCount = 0;
          } else if (events[type]) {
            if (--this._eventsCount === 0)
              this._events = new EventHandlers();
            else
              delete events[type];
          }
          return this;
        }

        // emit removeListener for all listeners on all events
        if (arguments.length === 0) {
          var keys = Object.keys(events);
          for (var i = 0, key; i < keys.length; ++i) {
            key = keys[i];
            if (key === 'removeListener') continue;
            this.removeAllListeners(key);
          }
          this.removeAllListeners('removeListener');
          this._events = new EventHandlers();
          this._eventsCount = 0;
          return this;
        }

        listeners = events[type];

        if (typeof listeners === 'function') {
          this.removeListener(type, listeners);
        } else if (listeners) {
          // LIFO order
          do {
            this.removeListener(type, listeners[listeners.length - 1]);
          } while (listeners[0]);
        }

        return this;
      };

  EventEmitter.prototype.listeners = function listeners(type) {
    var evlistener;
    var ret;
    var events = this._events;

    if (!events)
      ret = [];
    else {
      evlistener = events[type];
      if (!evlistener)
        ret = [];
      else if (typeof evlistener === 'function')
        ret = [evlistener.listener || evlistener];
      else
        ret = unwrapListeners(evlistener);
    }

    return ret;
  };

  EventEmitter.listenerCount = function(emitter, type) {
    if (typeof emitter.listenerCount === 'function') {
      return emitter.listenerCount(type);
    } else {
      return listenerCount.call(emitter, type);
    }
  };

  EventEmitter.prototype.listenerCount = listenerCount;
  function listenerCount(type) {
    var events = this._events;

    if (events) {
      var evlistener = events[type];

      if (typeof evlistener === 'function') {
        return 1;
      } else if (evlistener) {
        return evlistener.length;
      }
    }

    return 0;
  }

  EventEmitter.prototype.eventNames = function eventNames() {
    return this._eventsCount > 0 ? Reflect.ownKeys(this._events) : [];
  };

  // About 1.5x faster than the two-arg version of Array#splice().
  function spliceOne(list, index) {
    for (var i = index, k = i + 1, n = list.length; k < n; i += 1, k += 1)
      list[i] = list[k];
    list.pop();
  }

  function arrayClone(arr, i) {
    var copy = new Array(i);
    while (i--)
      copy[i] = arr[i];
    return copy;
  }

  function unwrapListeners(arr) {
    var ret = new Array(arr.length);
    for (var i = 0; i < ret.length; ++i) {
      ret[i] = arr[i].listener || arr[i];
    }
    return ret;
  }

  var pkg = {
  	name: "@nextgis/ngw-connector",
  	version: "3.0.1",
  	_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",
  		"@nextgis/cancelable-promise": "3.0.0",
  		"@nextgis/utils": "3.0.0",
  		"@types/events": "^3.0.0",
  		events: "*",
  		"form-data": "^4.0.0"
  	},
  	devDependencies: {
  		"@nextgis/build-tools": "3.0.0"
  	},
  	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"
  };

  class AbortError extends Error {
    constructor(message = "AbortError") {
      super(message);
      this.name = "AbortError";
    }
  }

  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$8 = (obj, key, value) => __defNormalProp$a(obj, typeof key !== "symbol" ? key + "" : key, value);
  class NgwError extends Error {
    constructor(er) {
      super();
      __publicField$8(this, "name", "NgwError");
      __publicField$8(this, "title");
      __publicField$8(this, "message");
      __publicField$8(this, "detail");
      __publicField$8(this, "exception");
      __publicField$8(this, "status_code");
      __publicField$8(this, "data");
      __publicField$8(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$7 = (obj, key, value) => __defNormalProp$9(obj, typeof key !== "symbol" ? key + "" : key, value);
  class InsufficientPermissionsError extends NgwError {
    constructor(obj) {
      super(obj);
      __publicField$7(this, "name", "InsufficientPermissionsError");
      __publicField$7(this, "exception", "nextgisweb.core.exception.InsufficientPermissions");
      Object.setPrototypeOf(this, InsufficientPermissionsError.prototype);
    }
  }

  var __defProp$8 = Object.defineProperty;
  var __defNormalProp$8 = (obj, key, value) => key in obj ? __defProp$8(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
  var __publicField$6 = (obj, key, value) => __defNormalProp$8(obj, typeof key !== "symbol" ? key + "" : key, value);
  let NetworksResponseError$1 = class NetworksResponseError extends NgwError {
    constructor(obj) {
      super(obj);
      __publicField$6(this, "message", "There is no response from the server or problem connecting to server.");
      __publicField$6(this, "title", "Network error");
      __publicField$6(this, "detail", "Check network connectivity and try again later.");
      Object.setPrototypeOf(this, NetworksResponseError.prototype);
    }
  };

  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."
      };
    }
  }

  function isError(error) {
    if (isObject$1(error)) {
      return error.status_code && error.exception && error.title;
    }
    return false;
  }

  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$5 = (obj, key, value) => __defNormalProp$7(obj, key + "" , value);
  class NetworkError extends Error {
    constructor(url) {
      super();
      __publicField$5(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$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$4 = (obj, key, value) => __defNormalProp$6(obj, typeof key !== "symbol" ? key + "" : key, value);
  class ResourceNotFoundError extends NgwError {
    constructor(obj) {
      super(obj);
      __publicField$4(this, "name", "ResourceNotFoundError");
      __publicField$4(this, "exception", "nextgisweb.resource.exception.ResourceNotFound");
      Object.setPrototypeOf(this, ResourceNotFoundError.prototype);
    }
  }

  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$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, 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);
      }
    }
  }
  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.";
    }
  }
  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);
      }
    }
  }
  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$4 = Object.defineProperty;
  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 __objRest$2 = (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 __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());
    });
  };
  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$3(this, null, function* () {
      try {
        return response.json();
      } catch (e) {
        throw new Error();
      }
    });
  }
  function lunkwillResponseUrl(lwResp) {
    return __async$3(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);
        }
      }
      return res;
    });
  }
  function lunkwillFetch(lwRespUrl) {
    return __async$3(this, null, function* () {
      try {
        return yield window.fetch(lwRespUrl, { credentials: "same-origin" });
      } catch (e) {
        throw new NetworksResponseError();
      }
    });
  }
  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 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$3(this, null, function* () {
      var _b, _c;
      const defaults = {
        method: "GET",
        credentials: "same-origin",
        headers: {}
      };
      const _a = __spreadValues$3(__spreadValues$3({}, defaults), options), {
        withCredentials,
        responseType,
        cacheProps,
        cacheName,
        lunkwill,
        cache,
        query,
        json
      } = _a, opt = __objRest$2(_a, [
        "withCredentials",
        "responseType",
        "cacheProps",
        "cacheName",
        "lunkwill",
        "cache",
        "query",
        "json"
      ]);
      opt.method = (_b = opt.method) == null ? void 0 : _b.toUpperCase();
      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$3(null, 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) {
        if (((_c = opt.method) == null ? void 0 : _c.toUpperCase()) === "GET") {
          if (cache !== false) {
            const props = cacheProps ? cacheProps : __spreadValues$3({}, objectRemoveEmpty({
              withCredentials,
              responseType
            }));
            return cacheEngine.add(cacheName || url, makeRequest, {
              props,
              expirationTime: cache ? void 0 : 500
            });
          }
        } else {
          const ignoredForClean = ["api/feature_layer/identify"];
          if (ignoredForClean.every((part) => !path.includes(part))) {
            cacheEngine.clean();
          }
        }
      }
      return makeRequest();
    });
  }

  var __defProp$3 = Object.defineProperty;
  var __defProps$2 = Object.defineProperties;
  var __getOwnPropDescs$2 = Object.getOwnPropertyDescriptors;
  var __getOwnPropSymbols$2 = Object.getOwnPropertySymbols;
  var __hasOwnProp$2 = Object.prototype.hasOwnProperty;
  var __propIsEnum$2 = Object.prototype.propertyIsEnumerable;
  var __defNormalProp$3 = (obj, key, value) => key in obj ? __defProp$3(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
  var __spreadValues$2 = (a, b) => {
    for (var prop in b || (b = {}))
      if (__hasOwnProp$2.call(b, prop))
        __defNormalProp$3(a, prop, b[prop]);
    if (__getOwnPropSymbols$2)
      for (var prop of __getOwnPropSymbols$2(b)) {
        if (__propIsEnum$2.call(b, prop))
          __defNormalProp$3(a, prop, b[prop]);
      }
    return a;
  };
  var __spreadProps$2 = (a, b) => __defProps$2(a, __getOwnPropDescs$2(b));
  var __objRest$1 = (source, exclude) => {
    var target = {};
    for (var prop in source)
      if (__hasOwnProp$2.call(source, prop) && exclude.indexOf(prop) < 0)
        target[prop] = source[prop];
    if (source != null && __getOwnPropSymbols$2)
      for (var prop of __getOwnPropSymbols$2(source)) {
        if (exclude.indexOf(prop) < 0 && __propIsEnum$2.call(source, prop))
          target[prop] = source[prop];
      }
    return target;
  };
  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());
    });
  };
  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$2(null, 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) => {
        var _b;
        const _a = requestOptions || {}, { headers: optHeaders } = _a, restOpt = __objRest$1(_a, ["headers"]);
        if ((_b = requestOptions == null ? void 0 : requestOptions.signal) == null ? void 0 : _b.aborted) {
          throw new AbortError();
        }
        return connector.connect().then((routeData) => {
          var _a2;
          const template = routeURL(
            name,
            (_a2 = connector.options.baseUrl) != null ? _a2 : "",
            routeData,
            ...rest
          );
          const headers = objectRemoveEmpty(__spreadValues$2(__spreadValues$2({}, connector.getAuthorizationHeaders()), optHeaders != null ? optHeaders : {}));
          return request(
            template,
            __spreadProps$2(__spreadValues$2({
              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 (e) {
          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 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);
    }
  }

  var __defProp$2 = Object.defineProperty;
  var __defProps$1 = Object.defineProperties;
  var __getOwnPropDescs$1 = Object.getOwnPropertyDescriptors;
  var __getOwnPropSymbols$1 = Object.getOwnPropertySymbols;
  var __hasOwnProp$1 = Object.prototype.hasOwnProperty;
  var __propIsEnum$1 = Object.prototype.propertyIsEnumerable;
  var __defNormalProp$2 = (obj, key, value) => key in obj ? __defProp$2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
  var __spreadValues$1 = (a, b) => {
    for (var prop in b || (b = {}))
      if (__hasOwnProp$1.call(b, prop))
        __defNormalProp$2(a, prop, b[prop]);
    if (__getOwnPropSymbols$1)
      for (var prop of __getOwnPropSymbols$1(b)) {
        if (__propIsEnum$1.call(b, prop))
          __defNormalProp$2(a, prop, b[prop]);
      }
    return a;
  };
  var __spreadProps$1 = (a, b) => __defProps$1(a, __getOwnPropDescs$1(b));
  var __objRest = (source, exclude) => {
    var target = {};
    for (var prop in source)
      if (__hasOwnProp$1.call(source, prop) && exclude.indexOf(prop) < 0)
        target[prop] = source[prop];
    if (source != null && __getOwnPropSymbols$1)
      for (var prop of __getOwnPropSymbols$1(source)) {
        if (exclude.indexOf(prop) < 0 && __propIsEnum$1.call(source, prop))
          target[prop] = source[prop];
      }
    return target;
  };
  var __publicField$2