@nextgis/leaflet-map-adapter 4.0.2 → 4.1.1

package/lib/leaflet-map-adapter.esm-browser.js

@@ -1,4 +1,4 @@
-/** Bundle of @nextgis/leaflet-map-adapter; version: 4.0.2; author: NextGIS */
+/** Bundle of @nextgis/leaflet-map-adapter; version: 4.1.1; author: NextGIS */
 function getElement(el) {
   if (typeof el === "string") {
     let el_ = document.getElementById(el);
@@ -15468,6 +15468,8 @@ function filterGeometries(data, type) {
     _data.geometries = _data.geometries.filter(
       (g) => geometryFilter(g.type, type)
     );
+  } else if (!geometryFilter(data.type, type)) {
+    return false;
   }
   return data;
 }
@@ -16019,6 +16021,9 @@ class GeoJsonAdapter extends BaseAdapter {
   }
   setData(data) {
     this.clearLayer();
+    if (!this.options.type) {
+      this.type = void 0;
+    }
     this.addData(data);
   }
   addData(data) {
@@ -16033,15 +16038,20 @@ class GeoJsonAdapter extends BaseAdapter {
         } else {
           type = options.type;
         }
+        if (!type) {
+          return;
+        }
         if (this.type && this.type !== type) {
           console.warn("no other data type than layer can be added");
           return;
         }
         this.type = type;
         data = filterGeometries(data, type);
-        if (data) {
-          geoJsonOptions = this._getGeoJsonOptions(options, type);
+        if (!data) {
+          console.warn("no other data type than layer can be added");
+          return;
         }
+        geoJsonOptions = this._getGeoJsonOptions(options, type);
       }
       new leafletSrcExports.GeoJSON(data || void 0, geoJsonOptions);
     }
@@ -16494,15 +16504,31 @@ class Queue {
   /**
    * @param {PromiseQueueOptions} options - Configuration options for the queue.
    */
-  constructor({ concurrency = 1, delay = 0 } = {}) {
+  constructor({
+    delay = 0,
+    limit,
+    timeout,
+    debounce,
+    concurrency = 1
+  } = {}) {
     __publicField$4(this, "queue", []);
+    __publicField$4(this, "activeRequests", []);
     __publicField$4(this, "concurrency");
-    __publicField$4(this, "activeCount", 0);
     __publicField$4(this, "timeoutId");
+    __publicField$4(this, "resumeTimer");
     __publicField$4(this, "delay");
-    __publicField$4(this, "toAbort", []);
-    this.concurrency = concurrency;
-    this.delay = delay;
+    __publicField$4(this, "timeout");
+    __publicField$4(this, "paused", false);
+    __publicField$4(this, "idleResolvers", []);
+    __publicField$4(this, "debounce");
+    this.concurrency = limit != null ? limit : concurrency;
+    this.delay = debounce != null ? debounce : delay;
+    this.debounce = this.delay;
+    this.timeout = timeout;
+  }
+  setLimit(limit) {
+    this.concurrency = limit;
+    this._next();
   }
   /**
    * Adds a task to the queue, which can be either a simple asynchronous function or an array containing a function and its abort handler.
@@ -16521,7 +16547,18 @@ class Queue {
    * ```
    */
   add(promise, abort) {
-    this.queue.push({ promise, abort });
+    var _a, _b;
+    const options = typeof abort === "function" ? { abort } : abort;
+    if ((options == null ? void 0 : options.id) !== void 0) {
+      this.removeById(options.id);
+    }
+    this.queue.push({
+      id: (_a = options == null ? void 0 : options.id) != null ? _a : Math.random().toString(36).slice(2),
+      promise,
+      abort: options == null ? void 0 : options.abort,
+      abortController: new AbortController(),
+      timeout: (_b = options == null ? void 0 : options.timeout) != null ? _b : this.timeout
+    });
     this.debouncedNext();
   }
   /**
@@ -16531,60 +16568,167 @@ class Queue {
    * queue.abort(); // Aborts all abortable tasks in the queue.
    */
   abort() {
-    for (const abort of this.toAbort) {
-      abort();
+    for (const item of [...this.queue, ...this.activeRequests]) {
+      this.abortRequest(item);
+      this.clearRequestTimeout(item);
+      item.completed = true;
+    }
+    this.queue.length = 0;
+    this.activeRequests.length = 0;
+    this._clearTimeout();
+    this.checkIdle();
+  }
+  remove(id) {
+    this.removeById(id);
+  }
+  clearQueue() {
+    for (const item of this.queue) {
+      this.abortRequest(item);
+      item.completed = true;
     }
-    this.toAbort = [];
-    this.queue = [];
+    this.queue.length = 0;
     this._clearTimeout();
+    this.checkIdle();
+  }
+  waitAll() {
+    return new Promise((resolve) => {
+      if (this.isIdle()) {
+        resolve();
+      } else {
+        this.idleResolvers.push(resolve);
+      }
+    });
+  }
+  pause(pauseDuration) {
+    this.paused = true;
+    this._clearTimeout();
+    this._clearResumeTimer();
+    if (pauseDuration) {
+      this.resumeTimer = setTimeout(() => this.resume(), pauseDuration);
+    }
+  }
+  resume() {
+    if (!this.paused) return;
+    this.paused = false;
+    this._clearResumeTimer();
+    this._next();
   }
   debouncedNext() {
+    if (this.paused) return;
+    if (this.activeRequests.length) {
+      this._next();
+      return;
+    }
     this._clearTimeout();
     this.timeoutId = setTimeout(() => this._next(), this.delay);
   }
   _clearTimeout() {
     if (this.timeoutId) {
       clearTimeout(this.timeoutId);
+      this.timeoutId = void 0;
+    }
+  }
+  _clearResumeTimer() {
+    if (this.resumeTimer) {
+      clearTimeout(this.resumeTimer);
+      this.resumeTimer = void 0;
     }
   }
   _next() {
-    while (this.activeCount < this.concurrency && this.queue.length > 0) {
-      const { promise, abort } = this.queue.shift();
-      this.activeCount++;
-      let toAbort = abort;
-      let request;
-      const execute = promise();
-      if (Array.isArray(execute)) {
-        request = execute[0];
-        toAbort = execute[1];
-      } else {
-        request = execute;
-      }
-      if (toAbort) {
-        this.toAbort.push(toAbort);
+    if (this.paused) return;
+    while (this.activeRequests.length < this.concurrency && this.queue.length) {
+      const item = this.queue.shift();
+      if (item.abortController.signal.aborted) continue;
+      this.activeRequests.push(item);
+      if (item.timeout && item.timeout > 0) {
+        item.timeoutId = setTimeout(() => {
+          this.abortRequest(
+            item,
+            new DOMException("Request timed out", "TimeoutError")
+          );
+          this.finishRequest(item);
+        }, item.timeout);
       }
-      request.finally(() => {
-        this.activeCount--;
-        if (toAbort) {
-          this.toAbort = this.toAbort.filter((a) => a !== toAbort);
+      try {
+        const execute = item.promise({ signal: item.abortController.signal });
+        const request = Array.isArray(execute) ? execute[0] : execute;
+        if (Array.isArray(execute)) {
+          const abort = item.abort;
+          item.abort = abort ? () => {
+            abort();
+            execute[1]();
+          } : execute[1];
         }
-        this.debouncedNext();
-      });
+        Promise.resolve(request).then(
+          () => this.finishRequest(item),
+          () => this.finishRequest(item)
+        );
+      } catch (error) {
+        this.finishRequest(item);
+        console.error(error);
+      }
+    }
+    this.checkIdle();
+  }
+  removeById(id) {
+    this.queue = this.queue.filter((item) => {
+      if (item.id !== id) return true;
+      this.abortRequest(item);
+      item.completed = true;
+      return false;
+    });
+    for (const item of [...this.activeRequests]) {
+      if (item.id === id) {
+        this.abortRequest(item);
+        this.finishRequest(item);
+      }
+    }
+    this.checkIdle();
+  }
+  abortRequest(item, reason) {
+    var _a;
+    if (!item.abortController.signal.aborted) {
+      item.abortController.abort(reason);
+    }
+    (_a = item.abort) == null ? void 0 : _a.call(item);
+  }
+  clearRequestTimeout(item) {
+    if (item.timeoutId) {
+      clearTimeout(item.timeoutId);
+      item.timeoutId = void 0;
+    }
+  }
+  finishRequest(item) {
+    if (item.completed) return;
+    item.completed = true;
+    this.clearRequestTimeout(item);
+    this.activeRequests = this.activeRequests.filter((x) => x !== item);
+    this.checkIdle();
+    this._next();
+  }
+  isIdle() {
+    return this.queue.length === 0 && this.activeRequests.length === 0;
+  }
+  checkIdle() {
+    if (this.isIdle()) {
+      this.idleResolvers.splice(0).forEach((resolve) => resolve());
     }
   }
 }
 
-const imageQueue = new Queue({ concurrency: 6, delay: 200 });
+const imageQueue = new Queue({ limit: 6, debounce: 150 });
 
 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$3 = (obj, key, value) => __defNormalProp$6(obj, key + "" , value);
+const transparentImage = "data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEAAAAALAAAAAABAAEAAAIBAAA=";
 class ImageOverlay extends leafletSrcExports.ImageOverlay {
   constructor(imageUrl, bounds, options) {
     super(imageUrl, bounds, options);
     __publicField$3(this, "_aborter");
   }
   cancelLoad() {
+    imageQueue.remove(leafletSrcExports.Util.stamp(this));
     if (this._aborter) {
       this._aborter();
       this._aborter = void 0;
@@ -16596,19 +16740,27 @@ class ImageOverlay extends leafletSrcExports.ImageOverlay {
     const img = this._image;
     const src = img.src;
     img.src = "";
-    imageQueue.add(() => {
-      const [promise, abortFunc] = callAjax({
-        src,
-        headers,
-        request,
-        withCredentials
-      });
-      promise.then((imgUrl) => {
-        img.src = imgUrl;
-      });
-      this._aborter = abortFunc;
-      return promise;
-    });
+    imageQueue.add(
+      ({ signal }) => {
+        const [promise, abortFunc] = callAjax({
+          src,
+          headers,
+          request,
+          withCredentials
+        });
+        void promise.then((imgUrl) => {
+          if (!signal.aborted) img.src = imgUrl || transparentImage;
+        }).catch((error) => {
+          if (!signal.aborted) {
+            console.error(error);
+            img.src = transparentImage;
+          }
+        });
+        this._aborter = abortFunc;
+        return [promise, abortFunc];
+      },
+      { id: leafletSrcExports.Util.stamp(this) }
+    );
   }
 }
 
@@ -16678,6 +16830,12 @@ class ImageLayer extends leafletSrcExports.Layer {
       map.removeLayer(this._currentOverlay);
       delete this._currentOverlay;
     }
+    if (this._loadedOverlay) {
+      this._loadedOverlay.cancelLoad();
+      this._loadedOverlay.off("load");
+      map.removeLayer(this._loadedOverlay);
+      this._loadedOverlay = void 0;
+    }
     if (this._currentUrl) {
       delete this._currentUrl;
     }
@@ -16703,6 +16861,7 @@ class ImageLayer extends leafletSrcExports.Layer {
     if (this._loadedOverlay) {
       this._loadedOverlay.cancelLoad();
       this._loadedOverlay.off("load");
+      this._map.removeLayer(this._loadedOverlay);
       this._loadedOverlay = void 0;
     }
     const overlay = new ImageOverlay(url, bounds, {
@@ -16753,6 +16912,7 @@ class ImageLayer extends leafletSrcExports.Layer {
     if (this._currentOverlay) {
       this._currentOverlay.setOpacity(opacity);
     }
+    this.fire("opacitychange", { opacity });
   }
   bringToBack() {
     this.options.isBack = true;
@@ -17363,10 +17523,10 @@ const _LeafletMapAdapter = class _LeafletMapAdapter {
         }
         const stop2 = () => {
           if (locationfound !== void 0) {
-            map.off("locationfound", locationFound);
+            map.off("locationfound", locationFound, this);
           }
           if (locationerror) {
-            map.off("locationerror", locationerror);
+            map.off("locationerror", locationerror, this);
           }
         };
         return { stop: stop2 };