@3clear/basegis 0.1.1 → 0.1.3

package/dist/leaflet-pixi-overlay-BSJNo_DO.js

@@ -0,0 +1,253 @@
+import b from "leaflet";
+import { r as R } from "./pixi-vendor-BFDHT3Bf.js";
+function O(p, t) {
+  for (var d = 0; d < t.length; d++) {
+    const l = t[d];
+    if (typeof l != "string" && !Array.isArray(l)) {
+      for (const _ in l)
+        if (_ !== "default" && !(_ in p)) {
+          const f = Object.getOwnPropertyDescriptor(l, _);
+          f && Object.defineProperty(p, _, f.get ? f : {
+            enumerable: !0,
+            get: () => l[_]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(p, Symbol.toStringTag, { value: "Module" }));
+}
+var m = { exports: {} }, x;
+function P() {
+  return x || (x = 1, (function(p) {
+    (function(t) {
+      p.exports = t(b, R);
+    })(function(t, d) {
+      var l = t.Point.prototype._round, _ = function() {
+        return this;
+      };
+      function f(e, i, n) {
+        var r = d.VERSION < "7" ? e.plugins.interaction : e.events;
+        i ? r.destroy() : n || (r.autoPreventDefault = !1);
+      }
+      function w(e) {
+        var i = e.getMaxZoom(), n = e.getMinZoom();
+        return i === 1 / 0 ? n + 8 : (i + n) / 2;
+      }
+      var s = {
+        options: {
+          // @option padding: Number = 0.1
+          // How much to extend the clip area around the map view (relative to its size)
+          // e.g. 0.1 would be 10% of map view in each direction
+          padding: 0.1,
+          // @option forceCanvas: Boolean = false
+          // Force use of a 2d-canvas
+          forceCanvas: !1,
+          // @option doubleBuffering: Boolean = false
+          // Help to prevent flicker when refreshing display on some devices (e.g. iOS devices)
+          // It is ignored if rendering is done with 2d-canvas
+          doubleBuffering: !1,
+          // @option resolution: Number = 1
+          // Resolution of the renderer canvas
+          resolution: t.Browser.retina ? 2 : 1,
+          // @option projectionZoom(map: map): Number
+          // return the layer projection zoom level
+          projectionZoom: w,
+          // @option destroyInteractionManager:  Boolean = false
+          // Destroy PIXI EventSystem
+          destroyInteractionManager: !1,
+          // @option
+          // Customize PIXI EventSystem autoPreventDefault property
+          // This option is ignored if destroyInteractionManager is set
+          autoPreventDefault: !0,
+          // @option resolution: Boolean = false
+          // Enables drawing buffer preservation
+          preserveDrawingBuffer: !1,
+          // @option resolution: Boolean = true
+          // Clear the canvas before the new render pass
+          clearBeforeRender: !0,
+          // @option shouldRedrawOnMove(e: moveEvent): Boolean
+          // filter move events that should trigger a layer redraw
+          shouldRedrawOnMove: function() {
+            return !1;
+          }
+        },
+        initialize: function(e, i, n) {
+          t.setOptions(this, n), t.stamp(this), this._drawCallback = e, this._pixiContainer = i, this._rendererOptions = {
+            resolution: this.options.resolution,
+            antialias: !0,
+            forceCanvas: this.options.forceCanvas,
+            preserveDrawingBuffer: this.options.preserveDrawingBuffer,
+            clearBeforeRender: this.options.clearBeforeRender
+          }, d.VERSION < "6" ? this._rendererOptions.transparent = !0 : this._rendererOptions.backgroundAlpha = 0, this._doubleBuffering = d.utils.isWebGLSupported() && !this.options.forceCanvas && this.options.doubleBuffering;
+        },
+        _setMap: function() {
+        },
+        _setContainerStyle: function() {
+        },
+        _addContainer: function() {
+          this.getPane().appendChild(this._container);
+        },
+        _setEvents: function() {
+        },
+        onAdd: function(e) {
+          if (this._setMap(e), !this._container) {
+            var i = this._container = t.DomUtil.create("div", "leaflet-pixi-overlay");
+            i.style.position = "absolute", this._renderer = d.autoDetectRenderer(this._rendererOptions), f(
+              this._renderer,
+              this.options.destroyInteractionManager,
+              this.options.autoPreventDefault
+            ), i.appendChild(this._renderer.view), this._zoomAnimated && (t.DomUtil.addClass(i, "leaflet-zoom-animated"), this._setContainerStyle()), this._doubleBuffering && (this._auxRenderer = d.autoDetectRenderer(this._rendererOptions), f(
+              this._auxRenderer,
+              this.options.destroyInteractionManager,
+              this.options.autoPreventDefault
+            ), i.appendChild(this._auxRenderer.view), this._renderer.view.style.position = "absolute", this._auxRenderer.view.style.position = "absolute");
+          }
+          this._addContainer(), this._setEvents();
+          var n = this._map;
+          this._initialZoom = this.options.projectionZoom(n), this._wgsOrigin = t.latLng([0, 0]), this._wgsInitialShift = n.project(this._wgsOrigin, this._initialZoom), this._mapInitialZoom = n.getZoom();
+          var r = this;
+          this.utils = {
+            latLngToLayerPoint: function(a, o) {
+              o = o === void 0 ? r._initialZoom : o;
+              var u = n.project(t.latLng(a), o);
+              return u;
+            },
+            layerPointToLatLng: function(a, o) {
+              o = o === void 0 ? r._initialZoom : o;
+              var u = t.point(a);
+              return n.unproject(u, o);
+            },
+            getScale: function(a) {
+              return a === void 0 ? n.getZoomScale(n.getZoom(), r._initialZoom) : n.getZoomScale(a, r._initialZoom);
+            },
+            getRenderer: function() {
+              return r._renderer;
+            },
+            getContainer: function() {
+              return r._pixiContainer;
+            },
+            getMap: function() {
+              return r._map;
+            }
+          }, this._update({ type: "add" });
+        },
+        onRemove: function() {
+          t.DomUtil.remove(this._container);
+        },
+        getEvents: function() {
+          var e = {
+            zoom: this._onZoom,
+            move: this._onMove,
+            moveend: this._update
+          };
+          return this._zoomAnimated && (e.zoomanim = this._onAnimZoom), e;
+        },
+        _onZoom: function() {
+          this._updateTransform(this._map.getCenter(), this._map.getZoom());
+        },
+        _onAnimZoom: function(e) {
+          this._updateTransform(e.center, e.zoom);
+        },
+        _onMove: function(e) {
+          this.options.shouldRedrawOnMove(e) && this._update(e);
+        },
+        _updateTransform: function(e, i) {
+          var n = this._map.getZoomScale(i, this._zoom), r = this._map.getSize().multiplyBy(0.5 + this.options.padding), a = this._map.project(this._center, i), o = r.multiplyBy(-n).add(a).subtract(this._map._getNewPixelOrigin(e, i));
+          t.Browser.any3d ? t.DomUtil.setTransform(this._container, o, n) : t.DomUtil.setPosition(this._container, o);
+        },
+        _redraw: function(e, i) {
+          this._disableLeafletRounding();
+          var n = this._map.getZoomScale(this._zoom, this._initialZoom), r = this._map.latLngToLayerPoint(this._wgsOrigin)._subtract(this._wgsInitialShift.multiplyBy(n))._subtract(e);
+          this._pixiContainer.scale.set(n), this._pixiContainer.position.set(r.x, r.y), this._drawCallback(this.utils, i), this._enableLeafletRounding();
+        },
+        _update: function(e) {
+          if (!(this._map._animatingZoom && this._bounds)) {
+            var i = this.options.padding, n = this._map.getSize(), r = this._map.containerPointToLayerPoint(n.multiplyBy(-i)).round();
+            if (this._bounds = new t.Bounds(r, r.add(n.multiplyBy(1 + i * 2)).round()), this._center = this._map.getCenter(), this._zoom = this._map.getZoom(), this._doubleBuffering) {
+              var a = this._renderer;
+              this._renderer = this._auxRenderer, this._auxRenderer = a;
+            }
+            var o = this._renderer.view, u = this._bounds, v = this._container, h = u.getSize();
+            if (!this._renderer.size || this._renderer.size.x !== h.x || this._renderer.size.y !== h.y) {
+              if (this._renderer.gl && (this._renderer.resolution = this.options.resolution, this._renderer.rootRenderTarget && (this._renderer.rootRenderTarget.resolution = this.options.resolution)), this._renderer.resize(h.x, h.y), o.style.width = h.x + "px", o.style.height = h.y + "px", this._renderer.gl) {
+                var g = this._renderer.gl;
+                if (g.drawingBufferWidth !== this._renderer.width) {
+                  var y = this.options.resolution * g.drawingBufferWidth / this._renderer.width;
+                  this._renderer.resolution = y, this._renderer.rootRenderTarget && (this._renderer.rootRenderTarget.resolution = y), this._renderer.resize(h.x, h.y);
+                }
+              }
+              this._renderer.size = h;
+            }
+            if (this._doubleBuffering) {
+              var c = this;
+              requestAnimationFrame(function() {
+                c._redraw(u.min, e), c._renderer.gl.finish(), o.style.visibility = "visible", c._auxRenderer.view.style.visibility = "hidden", t.DomUtil.setPosition(v, u.min);
+              });
+            } else
+              this._redraw(u.min, e), t.DomUtil.setPosition(v, u.min);
+          }
+        },
+        _disableLeafletRounding: function() {
+          t.Point.prototype._round = _;
+        },
+        _enableLeafletRounding: function() {
+          t.Point.prototype._round = l;
+        },
+        redraw: function(e) {
+          return this._map && (this._disableLeafletRounding(), this._drawCallback(this.utils, e), this._enableLeafletRounding()), this;
+        },
+        _destroy: function() {
+          this._renderer.destroy(!0), this._doubleBuffering && this._auxRenderer.destroy(!0);
+        },
+        destroy: function() {
+          this.remove(), this._destroy();
+        }
+      };
+      t.version >= "1" ? t.PixiOverlay = t.Layer.extend(s) : (t.Map.prototype.getZoomScale = function(e, i) {
+        var n = this.options.crs;
+        return i = i === void 0 ? this._zoom : i, n.scale(e) / n.scale(i);
+      }, t.DomUtil.setTransform = function(e, i, n) {
+        var r = i || new t.Point(0, 0);
+        e.style[t.DomUtil.TRANSFORM] = (t.Browser.ie3d ? "translate(" + r.x + "px," + r.y + "px)" : "translate3d(" + r.x + "px," + r.y + "px,0)") + (n ? " scale(" + n + ")" : "");
+      }, s.includes = t.Mixin.Events, s.addTo = function(e) {
+        return e.addLayer(this), this;
+      }, s._setMap = function(e) {
+        this._map = e, this._zoomAnimated = e._zoomAnimated;
+      }, s._setContainerStyle = function() {
+        var e = this;
+        [
+          "-webkit-transform-origin",
+          "-ms-transform-origin",
+          "transform-origin"
+        ].forEach(function(i) {
+          e._container.style[i] = "0 0";
+        });
+      }, s._addContainer = function() {
+        this._map.getPanes()[this.options.pane || "overlayPane"].appendChild(this._container);
+      }, s._setEvents = function() {
+        var e = this.getEvents();
+        for (var i in e)
+          this._map.on(i, e[i], this);
+      }, s.onRemove = function() {
+        var e = this._container.parentNode;
+        e && e.removeChild(this._container);
+        var i = this.getEvents();
+        for (var n in i)
+          this._map.off(n, i[n], this);
+        this._map = null;
+      }, s.destroy = function() {
+        var e = this._map || this._mapToAdd;
+        e && e.removeLayer(this), this._destroy();
+      }, t.PixiOverlay = t.Class.extend(s)), t.pixiOverlay = function(e, i, n) {
+        return t.Browser.canvas ? new t.PixiOverlay(e, i, n) : null;
+      };
+    });
+  })(m)), m.exports;
+}
+var C = P();
+const S = /* @__PURE__ */ O({
+  __proto__: null
+}, [C]);
+export {
+  S as L
+};