gisviewer-vue3-arcgis 1.0.281 → 1.0.282

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

@@ -0,0 +1,44 @@
+import { toRadians as r } from "./math.mjs";
+function i(e) {
+  if (e !== void 0)
+    return 0;
+}
+function t(e) {
+  if (e !== void 0)
+    return e;
+}
+function c(e) {
+  const u = 2 * Math.PI / e;
+  return (
+    /**
+     * @param {number|undefined} rotation Rotation.
+     * @param {boolean} [isMoving] True if an interaction or animation is in progress.
+     * @return {number|undefined} Rotation.
+     */
+    function(n, f) {
+      if (f)
+        return n;
+      if (n !== void 0)
+        return n = Math.floor(n / u + 0.5) * u, n;
+    }
+  );
+}
+function s(e) {
+  const u = e === void 0 ? r(5) : e;
+  return (
+    /**
+     * @param {number|undefined} rotation Rotation.
+     * @param {boolean} [isMoving] True if an interaction or animation is in progress.
+     * @return {number|undefined} Rotation.
+     */
+    function(n, f) {
+      return f || n === void 0 ? n : Math.abs(n) <= u ? 0 : n;
+    }
+  );
+}
+export {
+  c as createSnapToN,
+  s as createSnapToZero,
+  i as disable,
+  t as none
+};

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

@@ -0,0 +1,14 @@
+function f(n) {
+  return n[0] > 0 && n[1] > 0;
+}
+function a(n, r, u) {
+  return u === void 0 && (u = [0, 0]), u[0] = n[0] * r + 0.5 | 0, u[1] = n[1] * r + 0.5 | 0, u;
+}
+function c(n, r) {
+  return Array.isArray(n) ? n : (r === void 0 ? r = [n, n] : (r[0] = n, r[1] = n), r);
+}
+export {
+  f as hasArea,
+  a as scale,
+  c as toSize
+};

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

@@ -0,0 +1,101 @@
+import a from "../Object.mjs";
+import { get as o } from "../proj.mjs";
+class l extends a {
+  /**
+   * @param {Options} options Source options.
+   */
+  constructor(t) {
+    super(), this.projection = o(t.projection), this.attributions_ = s(t.attributions), this.attributionsCollapsible_ = t.attributionsCollapsible ?? !0, this.loading = !1, this.state_ = t.state !== void 0 ? t.state : "ready", this.wrapX_ = t.wrapX !== void 0 ? t.wrapX : !1, this.interpolate_ = !!t.interpolate, this.viewResolver = null, this.viewRejector = null;
+    const r = this;
+    this.viewPromise_ = new Promise(function(i, n) {
+      r.viewResolver = i, r.viewRejector = n;
+    });
+  }
+  /**
+   * Get the attribution function for the source.
+   * @return {?Attribution} Attribution function.
+   * @api
+   */
+  getAttributions() {
+    return this.attributions_;
+  }
+  /**
+   * @return {boolean} Attributions are collapsible.
+   * @api
+   */
+  getAttributionsCollapsible() {
+    return this.attributionsCollapsible_;
+  }
+  /**
+   * Get the projection of the source.
+   * @return {import("../proj/Projection.js").default|null} Projection.
+   * @api
+   */
+  getProjection() {
+    return this.projection;
+  }
+  /**
+   * @param {import("../proj/Projection").default} [projection] Projection.
+   * @return {Array<number>|null} Resolutions.
+   */
+  getResolutions(t) {
+    return null;
+  }
+  /**
+   * @return {Promise<import("../View.js").ViewOptions>} A promise for view-related properties.
+   */
+  getView() {
+    return this.viewPromise_;
+  }
+  /**
+   * Get the state of the source, see {@link import("./Source.js").State} for possible states.
+   * @return {import("./Source.js").State} State.
+   * @api
+   */
+  getState() {
+    return this.state_;
+  }
+  /**
+   * @return {boolean|undefined} Wrap X.
+   */
+  getWrapX() {
+    return this.wrapX_;
+  }
+  /**
+   * @return {boolean} Use linear interpolation when resampling.
+   */
+  getInterpolate() {
+    return this.interpolate_;
+  }
+  /**
+   * Refreshes the source. The source will be cleared, and data from the server will be reloaded.
+   * @api
+   */
+  refresh() {
+    this.changed();
+  }
+  /**
+   * Set the attributions of the source.
+   * @param {AttributionLike|undefined} attributions Attributions.
+   *     Can be passed as `string`, `Array<string>`, {@link module:ol/source/Source~Attribution},
+   *     or `undefined`.
+   * @api
+   */
+  setAttributions(t) {
+    this.attributions_ = s(t), this.changed();
+  }
+  /**
+   * Set the state of the source.
+   * @param {import("./Source.js").State} state State.
+   */
+  setState(t) {
+    this.state_ = t, this.changed();
+  }
+}
+function s(e) {
+  return e ? typeof e == "function" ? e : (Array.isArray(e) || (e = [e]), (t) => e) : null;
+}
+const c = l;
+export {
+  c as default
+};

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

@@ -0,0 +1,144 @@
+import a from "../events/Event.mjs";
+import { toSize as o, scale as c } from "../size.mjs";
+import { withinExtentAndZ as h } from "../tilecoord.mjs";
+import { getForProjection as u, wrapX as d } from "../tilegrid.mjs";
+import { getUid as g, abstract as G } from "../util.mjs";
+import f from "./Source.mjs";
+class P extends f {
+  /**
+   * @param {Options} options SourceTile source options.
+   */
+  constructor(i) {
+    super({
+      attributions: i.attributions,
+      attributionsCollapsible: i.attributionsCollapsible,
+      projection: i.projection,
+      state: i.state,
+      wrapX: i.wrapX,
+      interpolate: i.interpolate
+    }), this.on, this.once, this.un, this.tilePixelRatio_ = i.tilePixelRatio !== void 0 ? i.tilePixelRatio : 1, this.tileGrid = i.tileGrid !== void 0 ? i.tileGrid : null;
+    const t = [256, 256];
+    this.tileGrid && o(this.tileGrid.getTileSize(this.tileGrid.getMinZoom()), t), this.tmpSize = [0, 0], this.key_ = i.key || g(this), this.tileOptions = {
+      transition: i.transition,
+      interpolate: i.interpolate
+    }, this.zDirection = i.zDirection ? i.zDirection : 0;
+  }
+  /**
+   * @param {import("../proj/Projection.js").default} projection Projection.
+   * @return {number} Gutter.
+   */
+  getGutterForProjection(i) {
+    return 0;
+  }
+  /**
+   * Return the key to be used for all tiles in the source.
+   * @return {string} The key for all tiles.
+   */
+  getKey() {
+    return this.key_;
+  }
+  /**
+   * Set the value to be used as the key for all tiles in the source.
+   * @param {string} key The key for tiles.
+   * @protected
+   */
+  setKey(i) {
+    this.key_ !== i && (this.key_ = i, this.changed());
+  }
+  /**
+   * @param {import("../proj/Projection").default} [projection] Projection.
+   * @return {Array<number>|null} Resolutions.
+   * @override
+   */
+  getResolutions(i) {
+    const t = i ? this.getTileGridForProjection(i) : this.tileGrid;
+    return t ? t.getResolutions() : null;
+  }
+  /**
+   * @abstract
+   * @param {number} z Tile coordinate z.
+   * @param {number} x Tile coordinate x.
+   * @param {number} y Tile coordinate y.
+   * @param {number} pixelRatio Pixel ratio.
+   * @param {import("../proj/Projection.js").default} projection Projection.
+   * @param {import("../structs/LRUCache.js").default<import("../Tile.js").default>} [tileCache] Tile cache.
+   * @return {TileType|null} Tile.
+   */
+  getTile(i, t, e, r, l, n) {
+    return G();
+  }
+  /**
+   * Return the tile grid of the tile source.
+   * @return {import("../tilegrid/TileGrid.js").default|null} Tile grid.
+   * @api
+   */
+  getTileGrid() {
+    return this.tileGrid;
+  }
+  /**
+   * @param {import("../proj/Projection.js").default} projection Projection.
+   * @return {!import("../tilegrid/TileGrid.js").default} Tile grid.
+   */
+  getTileGridForProjection(i) {
+    return this.tileGrid ? this.tileGrid : u(i);
+  }
+  /**
+   * Get the tile pixel ratio for this source. Subclasses may override this
+   * method, which is meant to return a supported pixel ratio that matches the
+   * provided `pixelRatio` as close as possible.
+   * @param {number} pixelRatio Pixel ratio.
+   * @return {number} Tile pixel ratio.
+   */
+  getTilePixelRatio(i) {
+    return this.tilePixelRatio_;
+  }
+  /**
+   * @param {number} z Z.
+   * @param {number} pixelRatio Pixel ratio.
+   * @param {import("../proj/Projection.js").default} projection Projection.
+   * @return {import("../size.js").Size} Tile size.
+   */
+  getTilePixelSize(i, t, e) {
+    const r = this.getTileGridForProjection(e), l = this.getTilePixelRatio(t), n = o(r.getTileSize(i), this.tmpSize);
+    return l == 1 ? n : c(n, l, this.tmpSize);
+  }
+  /**
+   * Returns a tile coordinate wrapped around the x-axis. When the tile coordinate
+   * is outside the resolution and extent range of the tile grid, `null` will be
+   * returned.
+   * @param {import("../tilecoord.js").TileCoord} tileCoord Tile coordinate.
+   * @param {import("../proj/Projection.js").default} [projection] Projection.
+   * @return {import("../tilecoord.js").TileCoord} Tile coordinate to be passed to the tileUrlFunction or
+   *     null if no tile URL should be created for the passed `tileCoord`.
+   */
+  getTileCoordForTileUrlFunction(i, t) {
+    const e = t !== void 0 ? t : this.getProjection(), r = t !== void 0 ? this.getTileGridForProjection(e) : this.tileGrid || this.getTileGridForProjection(e);
+    return this.getWrapX() && e.isGlobal() && (i = d(r, i, e)), h(i, r) ? i : null;
+  }
+  /**
+   * Remove all cached reprojected tiles from the source. The next render cycle will create new tiles.
+   * @api
+   */
+  clear() {
+  }
+  /**
+   * @override
+   */
+  refresh() {
+    this.clear(), super.refresh();
+  }
+}
+class R extends a {
+  /**
+   * @param {string} type Type.
+   * @param {import("../Tile.js").default} tile The tile.
+   */
+  constructor(i, t) {
+    super(i), this.tile = t;
+  }
+}
+const j = P;
+export {
+  R as TileSourceEvent,
+  j as default
+};

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

@@ -0,0 +1,26 @@
+const e = {
+  /**
+   * Triggered when a tile starts loading.
+   * @event module:ol/source/Tile.TileSourceEvent#tileloadstart
+   * @api
+   */
+  TILELOADSTART: "tileloadstart",
+  /**
+   * Triggered when a tile finishes loading, either when its data is loaded,
+   * or when loading was aborted because the tile is no longer needed.
+   * @event module:ol/source/Tile.TileSourceEvent#tileloadend
+   * @api
+   */
+  TILELOADEND: "tileloadend",
+  /**
+   * Triggered if tile loading results in an error. Note that this is not the
+   * right place to re-fetch tiles. See {@link module:ol/ImageTile~ImageTile#load}
+   * for details.
+   * @event module:ol/source/Tile.TileSourceEvent#tileloaderror
+   * @api
+   */
+  TILELOADERROR: "tileloaderror"
+};
+export {
+  e as default
+};

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

@@ -0,0 +1,208 @@
+import m from "../ImageTile.mjs";
+import g from "../TileState.mjs";
+import y from "../events/EventType.mjs";
+import { WORKER_OFFSCREEN_CANVAS as I } from "../has.mjs";
+import { equivalent as u, get as w } from "../proj.mjs";
+import C from "../reproj/Tile.mjs";
+import { getCacheKey as R } from "../tilecoord.mjs";
+import { getForProjection as b } from "../tilegrid.mjs";
+import { getUid as f } from "../util.mjs";
+import v from "./UrlTile.mjs";
+class K extends v {
+  /**
+   * @param {!Options} options Image tile options.
+   */
+  constructor(e) {
+    super({
+      attributions: e.attributions,
+      cacheSize: e.cacheSize,
+      projection: e.projection,
+      state: e.state,
+      tileGrid: e.tileGrid,
+      tileLoadFunction: e.tileLoadFunction ? e.tileLoadFunction : O,
+      tilePixelRatio: e.tilePixelRatio,
+      tileUrlFunction: e.tileUrlFunction,
+      url: e.url,
+      urls: e.urls,
+      wrapX: e.wrapX,
+      transition: e.transition,
+      interpolate: e.interpolate !== void 0 ? e.interpolate : !0,
+      key: e.key,
+      attributionsCollapsible: e.attributionsCollapsible,
+      zDirection: e.zDirection
+    }), this.crossOrigin = e.crossOrigin !== void 0 ? e.crossOrigin : null, this.tileClass = e.tileClass !== void 0 ? e.tileClass : m, this.tileGridForProjection = {}, this.reprojectionErrorThreshold_ = e.reprojectionErrorThreshold, this.renderReprojectionEdges_ = !1;
+  }
+  /**
+   * @param {import("../proj/Projection.js").default} projection Projection.
+   * @return {number} Gutter.
+   * @override
+   */
+  getGutterForProjection(e) {
+    return this.getProjection() && e && !u(this.getProjection(), e) ? 0 : this.getGutter();
+  }
+  /**
+   * @return {number} Gutter.
+   */
+  getGutter() {
+    return 0;
+  }
+  /**
+   * Return the key to be used for all tiles in the source.
+   * @return {string} The key for all tiles.
+   * @override
+   */
+  getKey() {
+    let e = super.getKey();
+    return this.getInterpolate() || (e += ":disable-interpolation"), e;
+  }
+  /**
+   * @param {import("../proj/Projection.js").default} projection Projection.
+   * @return {!import("../tilegrid/TileGrid.js").default} Tile grid.
+   * @override
+   */
+  getTileGridForProjection(e) {
+    const i = this.getProjection();
+    if (this.tileGrid && (!i || u(i, e)))
+      return this.tileGrid;
+    const r = f(e);
+    return r in this.tileGridForProjection || (this.tileGridForProjection[r] = b(e)), this.tileGridForProjection[r];
+  }
+  /**
+   * @param {number} z Tile coordinate z.
+   * @param {number} x Tile coordinate x.
+   * @param {number} y Tile coordinate y.
+   * @param {number} pixelRatio Pixel ratio.
+   * @param {import("../proj/Projection.js").default} projection Projection.
+   * @param {string} key The key set on the tile.
+   * @return {!ImageTile} Tile.
+   * @private
+   */
+  createTile_(e, i, r, o, t, n) {
+    const s = [e, i, r], l = this.getTileCoordForTileUrlFunction(
+      s,
+      t
+    ), c = l ? this.tileUrlFunction(l, o, t) : void 0, d = new this.tileClass(
+      s,
+      c !== void 0 ? g.IDLE : g.EMPTY,
+      c !== void 0 ? c : "",
+      this.crossOrigin,
+      this.tileLoadFunction,
+      this.tileOptions
+    );
+    return d.key = n, d.addEventListener(y.CHANGE, this.handleTileChange.bind(this)), d;
+  }
+  /**
+   * @param {number} z Tile coordinate z.
+   * @param {number} x Tile coordinate x.
+   * @param {number} y Tile coordinate y.
+   * @param {number} pixelRatio Pixel ratio.
+   * @param {import("../proj/Projection.js").default} projection Projection.
+   * @param {import("../structs/LRUCache.js").default<import("../Tile.js").default>} [tileCache] Tile cache.
+   * @return {!(ImageTile|ReprojTile)} Tile.
+   * @override
+   */
+  getTile(e, i, r, o, t, n) {
+    const s = this.getProjection();
+    if (!s || !t || u(s, t))
+      return this.getTileInternal(
+        e,
+        i,
+        r,
+        o,
+        s || t
+      );
+    const l = [e, i, r], c = this.getKey(), d = this.getTileGridForProjection(s), T = this.getTileGridForProjection(t), F = this.getTileCoordForTileUrlFunction(
+      l,
+      t
+    ), a = new C(
+      s,
+      d,
+      t,
+      T,
+      l,
+      F,
+      this.getTilePixelRatio(o),
+      this.getGutter(),
+      (j, P, E, G) => this.getTileInternal(j, P, E, G, s, n),
+      this.reprojectionErrorThreshold_,
+      this.renderReprojectionEdges_,
+      this.tileOptions
+    );
+    return a.key = c, a;
+  }
+  /**
+   * @param {number} z Tile coordinate z.
+   * @param {number} x Tile coordinate x.
+   * @param {number} y Tile coordinate y.
+   * @param {number} pixelRatio Pixel ratio.
+   * @param {!import("../proj/Projection.js").default} projection Projection.
+   * @param {import("../structs/LRUCache.js").default<import("../Tile.js").default>} [tileCache] Tile cache.
+   * @return {!ImageTile} Tile.
+   * @protected
+   */
+  getTileInternal(e, i, r, o, t, n) {
+    const s = this.getKey(), l = R(this, s, e, i, r);
+    if (n && n.containsKey(l))
+      return (
+        /** @type {!ImageTile} */
+        n.get(l)
+      );
+    const c = this.createTile_(e, i, r, o, t, s);
+    return n == null || n.set(l, c), c;
+  }
+  /**
+   * Sets whether to render reprojection edges or not (usually for debugging).
+   * @param {boolean} render Render the edges.
+   * @api
+   */
+  setRenderReprojectionEdges(e) {
+    this.renderReprojectionEdges_ != e && (this.renderReprojectionEdges_ = e, this.changed());
+  }
+  /**
+   * Sets the tile grid to use when reprojecting the tiles to the given
+   * projection instead of the default tile grid for the projection.
+   *
+   * This can be useful when the default tile grid cannot be created
+   * (e.g. projection has no extent defined) or
+   * for optimization reasons (custom tile size, resolutions, ...).
+   *
+   * @param {import("../proj.js").ProjectionLike} projection Projection.
+   * @param {import("../tilegrid/TileGrid.js").default} tilegrid Tile grid to use for the projection.
+   * @api
+   */
+  setTileGridForProjection(e, i) {
+    const r = w(e);
+    if (r) {
+      const o = f(r);
+      o in this.tileGridForProjection || (this.tileGridForProjection[o] = i);
+    }
+  }
+}
+function O(h, e) {
+  if (I) {
+    const i = h.getCrossOrigin();
+    let r = "same-origin", o = "same-origin";
+    i === "anonymous" || i === "" ? (r = "cors", o = "omit") : i === "use-credentials" && (r = "cors", o = "include"), fetch(e, {
+      mode: r,
+      credentials: o
+    }).then((t) => {
+      if (!t.ok)
+        throw new Error(`HTTP ${t.status}`);
+      return t.blob();
+    }).then((t) => createImageBitmap(t)).then((t) => {
+      var l;
+      const n = h.getImage();
+      n.width = t.width, n.height = t.height, /** @type {OffscreenCanvas} */
+      n.getContext("2d").drawImage(t, 0, 0), (l = t.close) == null || l.call(t), n.dispatchEvent(new Event("load"));
+    }).catch(() => {
+      h.getImage().dispatchEvent(new Event("error"));
+    });
+    return;
+  }
+  h.getImage().src = e;
+}
+const z = K;
+export {
+  z as default,
+  O as defaultTileLoadFunction
+};