gisviewer-vue3-arcgis 1.0.281 → 1.0.282

package/es/node_modules/.pnpm/ol@10.7.0/node_modules/ol/source/VectorEventType.mjs

@@ -0,0 +1,48 @@
+const e = {
+  /**
+   * Triggered when a feature is added to the source.
+   * @event module:ol/source/Vector.VectorSourceEvent#addfeature
+   * @api
+   */
+  ADDFEATURE: "addfeature",
+  /**
+   * Triggered when a feature is updated.
+   * @event module:ol/source/Vector.VectorSourceEvent#changefeature
+   * @api
+   */
+  CHANGEFEATURE: "changefeature",
+  /**
+   * Triggered when the clear method is called on the source.
+   * @event module:ol/source/Vector.VectorSourceEvent#clear
+   * @api
+   */
+  CLEAR: "clear",
+  /**
+   * Triggered when a feature is removed from the source.
+   * See {@link module:ol/source/Vector~VectorSource#clear source.clear()} for exceptions.
+   * @event module:ol/source/Vector.VectorSourceEvent#removefeature
+   * @api
+   */
+  REMOVEFEATURE: "removefeature",
+  /**
+   * Triggered when features starts loading.
+   * @event module:ol/source/Vector.VectorSourceEvent#featuresloadstart
+   * @api
+   */
+  FEATURESLOADSTART: "featuresloadstart",
+  /**
+   * Triggered when features finishes loading.
+   * @event module:ol/source/Vector.VectorSourceEvent#featuresloadend
+   * @api
+   */
+  FEATURESLOADEND: "featuresloadend",
+  /**
+   * Triggered if feature loading results in an error.
+   * @event module:ol/source/Vector.VectorSourceEvent#featuresloaderror
+   * @api
+   */
+  FEATURESLOADERROR: "featuresloaderror"
+};
+export {
+  e as default
+};

package/es/node_modules/.pnpm/ol@10.7.0/node_modules/ol/source/WMTS.mjs

@@ -0,0 +1,174 @@
+import "../proj.mjs";
+import { createFromTileUrlFunctions as o } from "../tileurlfunction.mjs";
+import { expandUrl as h, appendParams as c } from "../uri.mjs";
+import m from "./TileImage.mjs";
+class g extends m {
+  /**
+   * @param {Options} options WMTS options.
+   */
+  constructor(e) {
+    const t = e.requestEncoding !== void 0 ? e.requestEncoding : "KVP", r = e.tileGrid;
+    let i = e.urls;
+    i === void 0 && e.url !== void 0 && (i = h(e.url)), super({
+      attributions: e.attributions,
+      attributionsCollapsible: e.attributionsCollapsible,
+      cacheSize: e.cacheSize,
+      crossOrigin: e.crossOrigin,
+      interpolate: e.interpolate,
+      projection: e.projection,
+      reprojectionErrorThreshold: e.reprojectionErrorThreshold,
+      tileClass: e.tileClass,
+      tileGrid: r,
+      tileLoadFunction: e.tileLoadFunction,
+      tilePixelRatio: e.tilePixelRatio,
+      urls: i,
+      wrapX: e.wrapX !== void 0 ? e.wrapX : !1,
+      transition: e.transition,
+      zDirection: e.zDirection
+    }), this.version_ = e.version !== void 0 ? e.version : "1.0.0", this.format_ = e.format !== void 0 ? e.format : "image/jpeg", this.dimensions_ = e.dimensions !== void 0 ? e.dimensions : {}, this.layer_ = e.layer, this.matrixSet_ = e.matrixSet, this.style_ = e.style, this.requestEncoding_ = t, this.setKey(this.getKeyForDimensions_()), i && i.length > 0 && (this.tileUrlFunction = o(
+      i.map(this.createFromWMTSTemplate.bind(this))
+    ));
+  }
+  /**
+   * Set the URLs to use for requests.
+   * URLs may contain OGC conform URL Template Variables: {TileMatrix}, {TileRow}, {TileCol}.
+   * @param {Array<string>} urls URLs.
+   * @override
+   */
+  setUrls(e) {
+    this.urls = e;
+    const t = e.join(`
+`);
+    this.setTileUrlFunction(
+      o(
+        e.map(this.createFromWMTSTemplate.bind(this))
+      ),
+      t
+    );
+  }
+  /**
+   * Get the dimensions, i.e. those passed to the constructor through the
+   * "dimensions" option, and possibly updated using the updateDimensions
+   * method.
+   * @return {!Object} Dimensions.
+   * @api
+   */
+  getDimensions() {
+    return this.dimensions_;
+  }
+  /**
+   * Return the image format of the WMTS source.
+   * @return {string} Format.
+   * @api
+   */
+  getFormat() {
+    return this.format_;
+  }
+  /**
+   * Return the layer of the WMTS source.
+   * @return {string} Layer.
+   * @api
+   */
+  getLayer() {
+    return this.layer_;
+  }
+  /**
+   * Return the matrix set of the WMTS source.
+   * @return {string} MatrixSet.
+   * @api
+   */
+  getMatrixSet() {
+    return this.matrixSet_;
+  }
+  /**
+   * Return the request encoding, either "KVP" or "REST".
+   * @return {RequestEncoding} Request encoding.
+   * @api
+   */
+  getRequestEncoding() {
+    return this.requestEncoding_;
+  }
+  /**
+   * Return the style of the WMTS source.
+   * @return {string} Style.
+   * @api
+   */
+  getStyle() {
+    return this.style_;
+  }
+  /**
+   * Return the version of the WMTS source.
+   * @return {string} Version.
+   * @api
+   */
+  getVersion() {
+    return this.version_;
+  }
+  /**
+   * @private
+   * @return {string} The key for the current dimensions.
+   */
+  getKeyForDimensions_() {
+    const e = this.urls ? this.urls.slice(0) : [];
+    for (const t in this.dimensions_)
+      e.push(t + "-" + this.dimensions_[t]);
+    return e.join("/");
+  }
+  /**
+   * Update the dimensions.
+   * @param {Object} dimensions Dimensions.
+   * @api
+   */
+  updateDimensions(e) {
+    Object.assign(this.dimensions_, e), this.setKey(this.getKeyForDimensions_());
+  }
+  /**
+   * @param {string} template Template.
+   * @return {import("../Tile.js").UrlFunction} Tile URL function.
+   */
+  createFromWMTSTemplate(e) {
+    const t = this.requestEncoding_, r = {
+      layer: this.layer_,
+      style: this.style_,
+      tilematrixset: this.matrixSet_
+    };
+    t == "KVP" && Object.assign(r, {
+      Service: "WMTS",
+      Request: "GetTile",
+      Version: this.version_,
+      Format: this.format_
+    }), e = t == "KVP" ? c(e, r) : e.replace(/\{(\w+?)\}/g, function(s, a) {
+      return a.toLowerCase() in r ? r[a.toLowerCase()] : s;
+    });
+    const i = (
+      /** @type {import("../tilegrid/WMTS.js").default} */
+      this.tileGrid
+    ), u = this.dimensions_;
+    return (
+      /**
+       * @param {import("../tilecoord.js").TileCoord} tileCoord Tile coordinate.
+       * @param {number} pixelRatio Pixel ratio.
+       * @param {import("../proj/Projection.js").default} projection Projection.
+       * @return {string|undefined} Tile URL.
+       */
+      function(s, a, _) {
+        if (!s)
+          return;
+        const l = {
+          TileMatrix: i.getMatrixId(s[0]),
+          TileCol: s[1],
+          TileRow: s[2]
+        };
+        Object.assign(l, u);
+        let n = e;
+        return t == "KVP" ? n = c(n, l) : n = n.replace(/\{(\w+?)\}/g, function(y, d) {
+          return encodeURIComponent(l[d]);
+        }), n;
+      }
+    );
+  }
+}
+const b = g;
+export {
+  b as default
+};

package/es/node_modules/.pnpm/ol@10.7.0/node_modules/ol/source/common.mjs

@@ -0,0 +1,4 @@
+const o = 4;
+export {
+  o as DECIMALS
+};

package/es/node_modules/.pnpm/ol@10.7.0/node_modules/ol/source/wms.mjs

@@ -0,0 +1,57 @@
+import { getWidth as E, getHeight as R } from "../extent.mjs";
+import { round as S } from "../math.mjs";
+import "../proj.mjs";
+import { compareVersions as I } from "../string.mjs";
+import { appendParams as f } from "../uri.mjs";
+import { DECIMALS as g } from "./common.mjs";
+const u = "1.3.0";
+function A(t, r, o, i, n) {
+  n.WIDTH = o[0], n.HEIGHT = o[1];
+  const e = i.getAxisOrientation(), c = I(n.VERSION, "1.3") >= 0;
+  n[c ? "CRS" : "SRS"] = i.getCode();
+  const s = c && e.startsWith("ne") ? [r[1], r[0], r[3], r[2]] : r;
+  return n.BBOX = s.join(","), f(t, n);
+}
+function h(t, r, o, i, n, e, c) {
+  e = Object.assign({ REQUEST: "GetMap" }, e);
+  const s = r / o, T = [
+    S(E(t) / s, g),
+    S(R(t) / s, g)
+  ];
+  if (o != 1)
+    switch (c) {
+      case "geoserver":
+        const O = 90 * o + 0.5 | 0;
+        "FORMAT_OPTIONS" in e ? e.FORMAT_OPTIONS += ";dpi:" + O : e.FORMAT_OPTIONS = "dpi:" + O;
+        break;
+      case "mapserver":
+        e.MAP_RESOLUTION = 90 * o;
+        break;
+      case "carmentaserver":
+      case "qgis":
+        e.DPI = 90 * o;
+        break;
+      default:
+        throw new Error("Unknown `serverType` configured");
+    }
+  return A(n, t, T, i, e);
+}
+function v(t, r) {
+  return Object.assign(
+    {
+      REQUEST: r,
+      SERVICE: "WMS",
+      VERSION: u,
+      FORMAT: "image/png",
+      STYLES: "",
+      TRANSPARENT: "TRUE"
+    },
+    t
+  );
+}
+export {
+  u as DEFAULT_VERSION,
+  h as getImageSrc,
+  v as getRequestParams,
+  A as getRequestUrl
+};

package/es/node_modules/.pnpm/ol@10.7.0/node_modules/ol/sphere.mjs

@@ -0,0 +1,11 @@
+import { toRadians as a } from "./math.mjs";
+const i = 63710088e-1;
+function l(n, o, t) {
+  t = t || i;
+  const s = a(n[1]), h = a(o[1]), M = (h - s) / 2, c = a(o[0] - n[0]) / 2, e = Math.sin(M) * Math.sin(M) + Math.sin(c) * Math.sin(c) * Math.cos(s) * Math.cos(h);
+  return 2 * t * Math.atan2(Math.sqrt(e), Math.sqrt(1 - e));
+}
+export {
+  i as DEFAULT_RADIUS,
+  l as getDistance
+};

package/es/node_modules/.pnpm/ol@10.7.0/node_modules/ol/string.mjs

@@ -0,0 +1,14 @@
+function c(o, i) {
+  const n = ("" + o).split("."), r = ("" + i).split(".");
+  for (let t = 0; t < Math.max(n.length, r.length); t++) {
+    const s = parseInt(n[t] || "0", 10), e = parseInt(r[t] || "0", 10);
+    if (s > e)
+      return 1;
+    if (e > s)
+      return -1;
+  }
+  return 0;
+}
+export {
+  c as compareVersions
+};

package/es/node_modules/.pnpm/ol@10.7.0/node_modules/ol/structs/LRUCache.mjs

@@ -0,0 +1,179 @@
+import n from "../Disposable.mjs";
+import { assert as i } from "../asserts.mjs";
+class r {
+  /**
+   * @param {number} [highWaterMark] High water mark.
+   */
+  constructor(e) {
+    this.highWaterMark = e !== void 0 ? e : 2048, this.count_ = 0, this.entries_ = {}, this.oldest_ = null, this.newest_ = null;
+  }
+  deleteOldest() {
+    const e = this.pop();
+    e instanceof n && e.dispose();
+  }
+  /**
+   * @return {boolean} Can expire cache.
+   */
+  canExpireCache() {
+    return this.highWaterMark > 0 && this.getCount() > this.highWaterMark;
+  }
+  /**
+   * Expire the cache. When the cache entry is a {@link module:ol/Disposable~Disposable},
+   * the entry will be disposed.
+   * @param {!Object<string, boolean>} [keep] Keys to keep. To be implemented by subclasses.
+   */
+  expireCache(e) {
+    for (; this.canExpireCache(); )
+      this.deleteOldest();
+  }
+  /**
+   * FIXME empty description for jsdoc
+   */
+  clear() {
+    for (; this.oldest_; )
+      this.deleteOldest();
+  }
+  /**
+   * @param {string} key Key.
+   * @return {boolean} Contains key.
+   */
+  containsKey(e) {
+    return this.entries_.hasOwnProperty(e);
+  }
+  /**
+   * @param {function(T, string, LRUCache<T>): ?} f The function
+   *     to call for every entry from the oldest to the newer. This function takes
+   *     3 arguments (the entry value, the entry key and the LRUCache object).
+   *     The return value is ignored.
+   */
+  forEach(e) {
+    let s = this.oldest_;
+    for (; s; )
+      e(s.value_, s.key_, this), s = s.newer;
+  }
+  /**
+   * @param {string} key Key.
+   * @param {*} [options] Options (reserved for subclasses).
+   * @return {T} Value.
+   */
+  get(e, s) {
+    const t = this.entries_[e];
+    return i(
+      t !== void 0,
+      "Tried to get a value for a key that does not exist in the cache"
+    ), t === this.newest_ || (t === this.oldest_ ? (this.oldest_ = /** @type {Entry} */
+    this.oldest_.newer, this.oldest_.older = null) : (t.newer.older = t.older, t.older.newer = t.newer), t.newer = null, t.older = this.newest_, this.newest_.newer = t, this.newest_ = t), t.value_;
+  }
+  /**
+   * Remove an entry from the cache.
+   * @param {string} key The entry key.
+   * @return {T} The removed entry.
+   */
+  remove(e) {
+    const s = this.entries_[e];
+    return i(
+      s !== void 0,
+      "Tried to get a value for a key that does not exist in the cache"
+    ), s === this.newest_ ? (this.newest_ = /** @type {Entry} */
+    s.older, this.newest_ && (this.newest_.newer = null)) : s === this.oldest_ ? (this.oldest_ = /** @type {Entry} */
+    s.newer, this.oldest_ && (this.oldest_.older = null)) : (s.newer.older = s.older, s.older.newer = s.newer), delete this.entries_[e], --this.count_, s.value_;
+  }
+  /**
+   * @return {number} Count.
+   */
+  getCount() {
+    return this.count_;
+  }
+  /**
+   * @return {Array<string>} Keys.
+   */
+  getKeys() {
+    const e = new Array(this.count_);
+    let s = 0, t;
+    for (t = this.newest_; t; t = t.older)
+      e[s++] = t.key_;
+    return e;
+  }
+  /**
+   * @return {Array<T>} Values.
+   */
+  getValues() {
+    const e = new Array(this.count_);
+    let s = 0, t;
+    for (t = this.newest_; t; t = t.older)
+      e[s++] = t.value_;
+    return e;
+  }
+  /**
+   * @return {T} Last value.
+   */
+  peekLast() {
+    return this.oldest_.value_;
+  }
+  /**
+   * @return {string} Last key.
+   */
+  peekLastKey() {
+    return this.oldest_.key_;
+  }
+  /**
+   * Get the key of the newest item in the cache.  Throws if the cache is empty.
+   * @return {string} The newest key.
+   */
+  peekFirstKey() {
+    return this.newest_.key_;
+  }
+  /**
+   * Return an entry without updating least recently used time.
+   * @param {string} key Key.
+   * @return {T|undefined} Value.
+   */
+  peek(e) {
+    var s;
+    return (s = this.entries_[e]) == null ? void 0 : s.value_;
+  }
+  /**
+   * @return {T} value Value.
+   */
+  pop() {
+    const e = this.oldest_;
+    return delete this.entries_[e.key_], e.newer && (e.newer.older = null), this.oldest_ = /** @type {Entry} */
+    e.newer, this.oldest_ || (this.newest_ = null), --this.count_, e.value_;
+  }
+  /**
+   * @param {string} key Key.
+   * @param {T} value Value.
+   */
+  replace(e, s) {
+    this.get(e), this.entries_[e].value_ = s;
+  }
+  /**
+   * @param {string} key Key.
+   * @param {T} value Value.
+   */
+  set(e, s) {
+    i(
+      !(e in this.entries_),
+      "Tried to set a value for a key that is used already"
+    );
+    const t = {
+      key_: e,
+      newer: null,
+      older: this.newest_,
+      value_: s
+    };
+    this.newest_ ? this.newest_.newer = t : this.oldest_ = t, this.newest_ = t, this.entries_[e] = t, ++this.count_;
+  }
+  /**
+   * Set a maximum number of entries for the cache.
+   * @param {number} size Cache size.
+   * @api
+   */
+  setSize(e) {
+    this.highWaterMark = e;
+  }
+}
+const _ = r;
+export {
+  _ as default
+};

package/es/node_modules/.pnpm/ol@10.7.0/node_modules/ol/structs/PriorityQueue.mjs

@@ -0,0 +1,150 @@
+import { assert as c } from "../asserts.mjs";
+import { clear as p } from "../obj.mjs";
+const _ = 1 / 0;
+class m {
+  /**
+   * @param {function(T): number} priorityFunction Priority function.
+   * @param {function(T): string} keyFunction Key function.
+   */
+  constructor(t, e) {
+    this.priorityFunction_ = t, this.keyFunction_ = e, this.elements_ = [], this.priorities_ = [], this.queuedElements_ = {};
+  }
+  /**
+   * FIXME empty description for jsdoc
+   */
+  clear() {
+    this.elements_.length = 0, this.priorities_.length = 0, p(this.queuedElements_);
+  }
+  /**
+   * Remove and return the highest-priority element. O(log N).
+   * @return {T} Element.
+   */
+  dequeue() {
+    const t = this.elements_, e = this.priorities_, s = t[0];
+    t.length == 1 ? (t.length = 0, e.length = 0) : (t[0] = /** @type {T} */
+    t.pop(), e[0] = /** @type {number} */
+    e.pop(), this.siftUp_(0));
+    const i = this.keyFunction_(s);
+    return delete this.queuedElements_[i], s;
+  }
+  /**
+   * Enqueue an element. O(log N).
+   * @param {T} element Element.
+   * @return {boolean} The element was added to the queue.
+   */
+  enqueue(t) {
+    c(
+      !(this.keyFunction_(t) in this.queuedElements_),
+      "Tried to enqueue an `element` that was already added to the queue"
+    );
+    const e = this.priorityFunction_(t);
+    return e != _ ? (this.elements_.push(t), this.priorities_.push(e), this.queuedElements_[this.keyFunction_(t)] = !0, this.siftDown_(0, this.elements_.length - 1), !0) : !1;
+  }
+  /**
+   * @return {number} Count.
+   */
+  getCount() {
+    return this.elements_.length;
+  }
+  /**
+   * Gets the index of the left child of the node at the given index.
+   * @param {number} index The index of the node to get the left child for.
+   * @return {number} The index of the left child.
+   * @private
+   */
+  getLeftChildIndex_(t) {
+    return t * 2 + 1;
+  }
+  /**
+   * Gets the index of the right child of the node at the given index.
+   * @param {number} index The index of the node to get the right child for.
+   * @return {number} The index of the right child.
+   * @private
+   */
+  getRightChildIndex_(t) {
+    return t * 2 + 2;
+  }
+  /**
+   * Gets the index of the parent of the node at the given index.
+   * @param {number} index The index of the node to get the parent for.
+   * @return {number} The index of the parent.
+   * @private
+   */
+  getParentIndex_(t) {
+    return t - 1 >> 1;
+  }
+  /**
+   * Make this a heap. O(N).
+   * @private
+   */
+  heapify_() {
+    let t;
+    for (t = (this.elements_.length >> 1) - 1; t >= 0; t--)
+      this.siftUp_(t);
+  }
+  /**
+   * @return {boolean} Is empty.
+   */
+  isEmpty() {
+    return this.elements_.length === 0;
+  }
+  /**
+   * @param {string} key Key.
+   * @return {boolean} Is key queued.
+   */
+  isKeyQueued(t) {
+    return t in this.queuedElements_;
+  }
+  /**
+   * @param {T} element Element.
+   * @return {boolean} Is queued.
+   */
+  isQueued(t) {
+    return this.isKeyQueued(this.keyFunction_(t));
+  }
+  /**
+   * @param {number} index The index of the node to move down.
+   * @private
+   */
+  siftUp_(t) {
+    const e = this.elements_, s = this.priorities_, i = e.length, h = e[t], r = s[t], n = t;
+    for (; t < i >> 1; ) {
+      const o = this.getLeftChildIndex_(t), l = this.getRightChildIndex_(t), u = l < i && s[l] < s[o] ? l : o;
+      e[t] = e[u], s[t] = s[u], t = u;
+    }
+    e[t] = h, s[t] = r, this.siftDown_(n, t);
+  }
+  /**
+   * @param {number} startIndex The index of the root.
+   * @param {number} index The index of the node to move up.
+   * @private
+   */
+  siftDown_(t, e) {
+    const s = this.elements_, i = this.priorities_, h = s[e], r = i[e];
+    for (; e > t; ) {
+      const n = this.getParentIndex_(e);
+      if (i[n] > r)
+        s[e] = s[n], i[e] = i[n], e = n;
+      else
+        break;
+    }
+    s[e] = h, i[e] = r;
+  }
+  /**
+   * FIXME empty description for jsdoc
+   */
+  reprioritize() {
+    const t = this.priorityFunction_, e = this.elements_, s = this.priorities_;
+    let i = 0;
+    const h = e.length;
+    let r, n, o;
+    for (n = 0; n < h; ++n)
+      r = e[n], o = t(r), o == _ ? delete this.queuedElements_[this.keyFunction_(r)] : (s[i] = o, e[i++] = r);
+    e.length = i, s.length = i, this.heapify_();
+  }
+}
+const f = m;
+export {
+  _ as DROP,
+  f as default
+};