gisviewer-vue3-arcgis 1.0.281 → 1.0.283

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

@@ -0,0 +1,116 @@
+import r from "./TileState.mjs";
+import { easeIn as n } from "./easing.mjs";
+import a from "./events/EventType.mjs";
+import o from "./events/Target.mjs";
+import { abstract as h } from "./util.mjs";
+class l extends o {
+  /**
+   * @param {import("./tilecoord.js").TileCoord} tileCoord Tile coordinate.
+   * @param {import("./TileState.js").default} state State.
+   * @param {Options} [options] Tile options.
+   */
+  constructor(i, e, t) {
+    super(), t = t || {}, this.tileCoord = i, this.state = e, this.key = "", this.transition_ = t.transition === void 0 ? 250 : t.transition, this.transitionStarts_ = {}, this.interpolate = !!t.interpolate;
+  }
+  /**
+   * @protected
+   */
+  changed() {
+    this.dispatchEvent(a.CHANGE);
+  }
+  /**
+   * Called by the tile cache when the tile is removed from the cache due to expiry
+   */
+  release() {
+    this.setState(r.EMPTY);
+  }
+  /**
+   * @return {string} Key.
+   */
+  getKey() {
+    return this.key + "/" + this.tileCoord;
+  }
+  /**
+   * Get the tile coordinate for this tile.
+   * @return {import("./tilecoord.js").TileCoord} The tile coordinate.
+   * @api
+   */
+  getTileCoord() {
+    return this.tileCoord;
+  }
+  /**
+   * @return {import("./TileState.js").default} State.
+   */
+  getState() {
+    return this.state;
+  }
+  /**
+   * Sets the state of this tile. If you write your own {@link module:ol/Tile~LoadFunction tileLoadFunction} ,
+   * it is important to set the state correctly to {@link module:ol/TileState~ERROR}
+   * when the tile cannot be loaded. Otherwise the tile cannot be removed from
+   * the tile queue and will block other requests.
+   * @param {import("./TileState.js").default} state State.
+   * @api
+   */
+  setState(i) {
+    if (this.state !== r.EMPTY) {
+      if (this.state !== r.ERROR && this.state > i)
+        throw new Error("Tile load sequence violation");
+      this.state = i, this.changed();
+    }
+  }
+  /**
+   * Load the image or retry if loading previously failed.
+   * Loading is taken care of by the tile queue, and calling this method is
+   * only needed for preloading or for reloading in case of an error.
+   * @abstract
+   * @api
+   */
+  load() {
+    h();
+  }
+  /**
+   * Get the alpha value for rendering.
+   * @param {string} id An id for the renderer.
+   * @param {number} time The render frame time.
+   * @return {number} A number between 0 and 1.
+   */
+  getAlpha(i, e) {
+    if (!this.transition_)
+      return 1;
+    let t = this.transitionStarts_[i];
+    if (!t)
+      t = e, this.transitionStarts_[i] = t;
+    else if (t === -1)
+      return 1;
+    const s = e - t + 1e3 / 60;
+    return s >= this.transition_ ? 1 : n(s / this.transition_);
+  }
+  /**
+   * Determine if a tile is in an alpha transition.  A tile is considered in
+   * transition if tile.getAlpha() has not yet been called or has been called
+   * and returned 1.
+   * @param {string} id An id for the renderer.
+   * @return {boolean} The tile is in transition.
+   */
+  inTransition(i) {
+    return this.transition_ ? this.transitionStarts_[i] !== -1 : !1;
+  }
+  /**
+   * Mark a transition as complete.
+   * @param {string} id An id for the renderer.
+   */
+  endTransition(i) {
+    this.transition_ && (this.transitionStarts_[i] = -1);
+  }
+  /**
+   * @override
+   */
+  disposeInternal() {
+    this.release(), super.disposeInternal();
+  }
+}
+const p = l;
+export {
+  p as default
+};

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

@@ -0,0 +1,69 @@
+import a from "./TileState.mjs";
+import h from "./events/EventType.mjs";
+import r, { DROP as g } from "./structs/PriorityQueue.mjs";
+class u extends r {
+  /**
+   * @param {PriorityFunction} tilePriorityFunction Tile priority function.
+   * @param {function(): ?} tileChangeCallback Function called on each tile change event.
+   */
+  constructor(i, t) {
+    super(
+      (e) => i.apply(null, e),
+      (e) => e[0].getKey()
+    ), this.boundHandleTileChange_ = this.handleTileChange.bind(this), this.tileChangeCallback_ = t, this.tilesLoading_ = 0, this.tilesLoadingKeys_ = {};
+  }
+  /**
+   * @param {TileQueueElement} element Element.
+   * @return {boolean} The element was added to the queue.
+   * @override
+   */
+  enqueue(i) {
+    const t = super.enqueue(i);
+    return t && i[0].addEventListener(h.CHANGE, this.boundHandleTileChange_), t;
+  }
+  /**
+   * @return {number} Number of tiles loading.
+   */
+  getTilesLoading() {
+    return this.tilesLoading_;
+  }
+  /**
+   * @param {import("./events/Event.js").default} event Event.
+   * @protected
+   */
+  handleTileChange(i) {
+    const t = (
+      /** @type {import("./Tile.js").default} */
+      i.target
+    ), e = t.getState();
+    if (e === a.LOADED || e === a.ERROR || e === a.EMPTY) {
+      e !== a.ERROR && t.removeEventListener(h.CHANGE, this.boundHandleTileChange_);
+      const s = t.getKey();
+      s in this.tilesLoadingKeys_ && (delete this.tilesLoadingKeys_[s], --this.tilesLoading_), this.tileChangeCallback_();
+    }
+  }
+  /**
+   * @param {number} maxTotalLoading Maximum number tiles to load simultaneously.
+   * @param {number} maxNewLoads Maximum number of new tiles to load.
+   */
+  loadMoreTiles(i, t) {
+    let e = 0;
+    for (; this.tilesLoading_ < i && e < t && this.getCount() > 0; ) {
+      const s = this.dequeue()[0], l = s.getKey();
+      s.getState() === a.IDLE && !(l in this.tilesLoadingKeys_) && (this.tilesLoadingKeys_[l] = !0, ++this.tilesLoading_, ++e, s.load());
+    }
+  }
+}
+const _ = u;
+function y(n, i, t, e, s) {
+  if (!n || !(t in n.wantedTiles))
+    return g;
+  if (!n.wantedTiles[t][i.getKey()])
+    return g;
+  const l = n.viewState.center, o = e[0] - l[0], d = e[1] - l[1];
+  return 65536 * Math.log(s) + Math.sqrt(o * o + d * d) / s;
+}
+export {
+  _ as default,
+  y as getTilePriority
+};

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

@@ -0,0 +1,79 @@
+class n {
+  /**
+   * @param {number} minX Minimum X.
+   * @param {number} maxX Maximum X.
+   * @param {number} minY Minimum Y.
+   * @param {number} maxY Maximum Y.
+   */
+  constructor(i, s, t, m) {
+    this.minX = i, this.maxX = s, this.minY = t, this.maxY = m;
+  }
+  /**
+   * @param {import("./tilecoord.js").TileCoord} tileCoord Tile coordinate.
+   * @return {boolean} Contains tile coordinate.
+   */
+  contains(i) {
+    return this.containsXY(i[1], i[2]);
+  }
+  /**
+   * @param {TileRange} tileRange Tile range.
+   * @return {boolean} Contains.
+   */
+  containsTileRange(i) {
+    return this.minX <= i.minX && i.maxX <= this.maxX && this.minY <= i.minY && i.maxY <= this.maxY;
+  }
+  /**
+   * @param {number} x Tile coordinate x.
+   * @param {number} y Tile coordinate y.
+   * @return {boolean} Contains coordinate.
+   */
+  containsXY(i, s) {
+    return this.minX <= i && i <= this.maxX && this.minY <= s && s <= this.maxY;
+  }
+  /**
+   * @param {TileRange} tileRange Tile range.
+   * @return {boolean} Equals.
+   */
+  equals(i) {
+    return this.minX == i.minX && this.minY == i.minY && this.maxX == i.maxX && this.maxY == i.maxY;
+  }
+  /**
+   * @param {TileRange} tileRange Tile range.
+   */
+  extend(i) {
+    i.minX < this.minX && (this.minX = i.minX), i.maxX > this.maxX && (this.maxX = i.maxX), i.minY < this.minY && (this.minY = i.minY), i.maxY > this.maxY && (this.maxY = i.maxY);
+  }
+  /**
+   * @return {number} Height.
+   */
+  getHeight() {
+    return this.maxY - this.minY + 1;
+  }
+  /**
+   * @return {import("./size.js").Size} Size.
+   */
+  getSize() {
+    return [this.getWidth(), this.getHeight()];
+  }
+  /**
+   * @return {number} Width.
+   */
+  getWidth() {
+    return this.maxX - this.minX + 1;
+  }
+  /**
+   * @param {TileRange} tileRange Tile range.
+   * @return {boolean} Intersects.
+   */
+  intersects(i) {
+    return this.minX <= i.maxX && this.maxX >= i.minX && this.minY <= i.maxY && this.maxY >= i.minY;
+  }
+}
+function X(h, i, s, t, m) {
+  return m !== void 0 ? (m.minX = h, m.maxX = i, m.minY = s, m.maxY = t, m) : new n(h, i, s, t);
+}
+const Y = n;
+export {
+  X as createOrUpdate,
+  Y as default
+};

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

@@ -0,0 +1,14 @@
+const t = {
+  IDLE: 0,
+  LOADING: 1,
+  LOADED: 2,
+  /**
+   * Indicates that tile loading failed
+   * @type {number}
+   */
+  ERROR: 3,
+  EMPTY: 4
+};
+export {
+  t as default
+};