gisviewer-vue3-arcgis 1.0.280 → 1.0.282

package/es/node_modules/.pnpm/ol@10.7.0/node_modules/ol/layer/Layer.mjs

@@ -0,0 +1,289 @@
+import u from "../View.mjs";
+import { assert as c } from "../asserts.mjs";
+import d from "../events/EventType.mjs";
+import { unlistenByKey as o, listen as h } from "../events.mjs";
+import { intersects as y } from "../extent.mjs";
+import f from "../render/EventType.mjs";
+import g from "./Base.mjs";
+import a from "./Property.mjs";
+class m extends g {
+  /**
+   * @param {Options<SourceType>} options Layer options.
+   */
+  constructor(e) {
+    const r = Object.assign({}, e);
+    delete r.source, super(r), this.on, this.once, this.un, this.mapPrecomposeKey_ = null, this.mapRenderKey_ = null, this.sourceChangeKey_ = null, this.renderer_ = null, this.sourceReady_ = !1, this.rendered = !1, e.render && (this.render = e.render), e.map && this.setMap(e.map), this.addChangeListener(
+      a.SOURCE,
+      this.handleSourcePropertyChange_
+    );
+    const t = e.source ? (
+      /** @type {SourceType} */
+      e.source
+    ) : null;
+    this.setSource(t);
+  }
+  /**
+   * @param {Array<import("./Layer.js").default>} [array] Array of layers (to be modified in place).
+   * @return {Array<import("./Layer.js").default>} Array of layers.
+   * @override
+   */
+  getLayersArray(e) {
+    return e = e || [], e.push(this), e;
+  }
+  /**
+   * @param {Array<import("./Layer.js").State>} [states] Optional list of layer states (to be modified in place).
+   * @return {Array<import("./Layer.js").State>} List of layer states.
+   * @override
+   */
+  getLayerStatesArray(e) {
+    return e = e || [], e.push(this.getLayerState()), e;
+  }
+  /**
+   * Get the layer source.
+   * @return {SourceType|null} The layer source (or `null` if not yet set).
+   * @observable
+   * @api
+   */
+  getSource() {
+    return (
+      /** @type {SourceType} */
+      this.get(a.SOURCE) || null
+    );
+  }
+  /**
+   * @return {SourceType|null} The source being rendered.
+   */
+  getRenderSource() {
+    return this.getSource();
+  }
+  /**
+   * @return {import("../source/Source.js").State} Source state.
+   * @override
+   */
+  getSourceState() {
+    const e = this.getSource();
+    return e ? e.getState() : "undefined";
+  }
+  /**
+   * @private
+   */
+  handleSourceChange_() {
+    this.changed(), !(this.sourceReady_ || this.getSource().getState() !== "ready") && (this.sourceReady_ = !0, this.dispatchEvent("sourceready"));
+  }
+  /**
+   * @private
+   */
+  handleSourcePropertyChange_() {
+    this.sourceChangeKey_ && (o(this.sourceChangeKey_), this.sourceChangeKey_ = null), this.sourceReady_ = !1;
+    const e = this.getSource();
+    e && (this.sourceChangeKey_ = h(
+      e,
+      d.CHANGE,
+      this.handleSourceChange_,
+      this
+    ), e.getState() === "ready" && (this.sourceReady_ = !0, setTimeout(() => {
+      this.dispatchEvent("sourceready");
+    }, 0))), this.changed();
+  }
+  /**
+   * @param {import("../pixel").Pixel} pixel Pixel.
+   * @return {Promise<Array<import("../Feature").FeatureLike>>} Promise that resolves with
+   * an array of features.
+   */
+  getFeatures(e) {
+    return this.renderer_ ? this.renderer_.getFeatures(e) : Promise.resolve([]);
+  }
+  /**
+   * @param {import("../pixel").Pixel} pixel Pixel.
+   * @return {Uint8ClampedArray|Uint8Array|Float32Array|DataView|null} Pixel data.
+   */
+  getData(e) {
+    return !this.renderer_ || !this.rendered ? null : this.renderer_.getData(e);
+  }
+  /**
+   * The layer is visible on the map view, i.e. within its min/max resolution or zoom and
+   * extent, not set to `visible: false`, and not inside a layer group that is set
+   * to `visible: false`.
+   * @param {View|import("../View.js").ViewStateLayerStateExtent} [view] View or {@link import("../Map.js").FrameState}.
+   * Only required when the layer is not added to a map.
+   * @return {boolean} The layer is visible in the map view.
+   * @api
+   */
+  isVisible(e) {
+    let r;
+    const t = this.getMapInternal();
+    !e && t && (e = t.getView()), e instanceof u ? r = {
+      viewState: e.getState(),
+      extent: e.calculateExtent()
+    } : r = e, !r.layerStatesArray && t && (r.layerStatesArray = t.getLayerGroup().getLayerStatesArray());
+    let s;
+    if (r.layerStatesArray) {
+      if (s = r.layerStatesArray.find(
+        (l) => l.layer === this
+      ), !s)
+        return !1;
+    } else
+      s = this.getLayerState();
+    const i = this.getExtent();
+    return p(s, r.viewState) && (!i || y(i, r.extent));
+  }
+  /**
+   * Get the attributions of the source of this layer for the given view.
+   * @param {View|import("../View.js").ViewStateLayerStateExtent} [view] View or {@link import("../Map.js").FrameState}.
+   * Only required when the layer is not added to a map.
+   * @return {Array<string>} Attributions for this layer at the given view.
+   * @api
+   */
+  getAttributions(e) {
+    var i;
+    if (!this.isVisible(e))
+      return [];
+    const r = (i = this.getSource()) == null ? void 0 : i.getAttributions();
+    if (!r)
+      return [];
+    const t = e instanceof u ? e.getViewStateAndExtent() : e;
+    let s = r(t);
+    return Array.isArray(s) || (s = [s]), s;
+  }
+  /**
+   * In charge to manage the rendering of the layer. One layer type is
+   * bounded with one layer renderer.
+   * @param {?import("../Map.js").FrameState} frameState Frame state.
+   * @param {HTMLElement} target Target which the renderer may (but need not) use
+   * for rendering its content.
+   * @return {HTMLElement|null} The rendered element.
+   */
+  render(e, r) {
+    const t = this.getRenderer();
+    return t.prepareFrame(e) ? (this.rendered = !0, t.renderFrame(e, r)) : null;
+  }
+  /**
+   * Called when a layer is not visible during a map render.
+   */
+  unrender() {
+    this.rendered = !1;
+  }
+  /** @return {string} Declutter */
+  getDeclutter() {
+  }
+  /**
+   * @param {import("../Map.js").FrameState} frameState Frame state.
+   * @param {import("../layer/Layer.js").State} layerState Layer state.
+   */
+  renderDeclutter(e, r) {
+  }
+  /**
+   * When the renderer follows a layout -> render approach, do the final rendering here.
+   * @param {import('../Map.js').FrameState} frameState Frame state
+   */
+  renderDeferred(e) {
+    const r = this.getRenderer();
+    r && r.renderDeferred(e);
+  }
+  /**
+   * For use inside the library only.
+   * @param {import("../Map.js").default|null} map Map.
+   */
+  setMapInternal(e) {
+    e || this.unrender(), this.set(a.MAP, e);
+  }
+  /**
+   * For use inside the library only.
+   * @return {import("../Map.js").default|null} Map.
+   */
+  getMapInternal() {
+    return this.get(a.MAP);
+  }
+  /**
+   * Sets the layer to be rendered on top of other layers on a map. The map will
+   * not manage this layer in its layers collection. This
+   * is useful for temporary layers. To remove an unmanaged layer from the map,
+   * use `#setMap(null)`.
+   *
+   * To add the layer to a map and have it managed by the map, use
+   * {@link module:ol/Map~Map#addLayer} instead.
+   * @param {import("../Map.js").default|null} map Map.
+   * @api
+   */
+  setMap(e) {
+    this.mapPrecomposeKey_ && (o(this.mapPrecomposeKey_), this.mapPrecomposeKey_ = null), e || this.changed(), this.mapRenderKey_ && (o(this.mapRenderKey_), this.mapRenderKey_ = null), e && (this.mapPrecomposeKey_ = h(
+      e,
+      f.PRECOMPOSE,
+      this.handlePrecompose_,
+      this
+    ), this.mapRenderKey_ = h(this, d.CHANGE, e.render, e), this.changed());
+  }
+  /**
+   * @param {import("../events/Event.js").default} renderEvent Render event
+   * @private
+   */
+  handlePrecompose_(e) {
+    const r = (
+      /** @type {import("../render/Event.js").default} */
+      e.frameState.layerStatesArray
+    ), t = this.getLayerState(!1);
+    c(
+      !r.some(
+        (s) => s.layer === t.layer
+      ),
+      "A layer can only be added to the map once. Use either `layer.setMap()` or `map.addLayer()`, not both."
+    ), r.push(t);
+  }
+  /**
+   * Set the layer source.
+   * @param {SourceType|null} source The layer source.
+   * @observable
+   * @api
+   */
+  setSource(e) {
+    this.set(a.SOURCE, e);
+  }
+  /**
+   * Get the renderer for this layer.
+   * @return {RendererType|null} The layer renderer.
+   */
+  getRenderer() {
+    return this.renderer_ || (this.renderer_ = this.createRenderer()), this.renderer_;
+  }
+  /**
+   * @return {boolean} The layer has a renderer.
+   */
+  hasRenderer() {
+    return !!this.renderer_;
+  }
+  /**
+   * Create a renderer for this layer.
+   * @return {RendererType} A layer renderer.
+   * @protected
+   */
+  createRenderer() {
+    return null;
+  }
+  /**
+   * This will clear the renderer so that a new one can be created next time it is needed
+   */
+  clearRenderer() {
+    this.renderer_ && (this.renderer_.dispose(), delete this.renderer_);
+  }
+  /**
+   * Clean up.
+   * @override
+   */
+  disposeInternal() {
+    this.clearRenderer(), this.setSource(null), super.disposeInternal();
+  }
+}
+function p(n, e) {
+  if (!n.visible)
+    return !1;
+  const r = e.resolution;
+  if (r < n.minResolution || r >= n.maxResolution)
+    return !1;
+  const t = e.zoom;
+  return t > n.minZoom && t <= n.maxZoom;
+}
+const L = m;
+export {
+  L as default,
+  p as inView
+};

package/es/node_modules/.pnpm/ol@10.7.0/node_modules/ol/layer/Property.mjs

@@ -0,0 +1,15 @@
+const o = {
+  OPACITY: "opacity",
+  VISIBLE: "visible",
+  EXTENT: "extent",
+  Z_INDEX: "zIndex",
+  MAX_RESOLUTION: "maxResolution",
+  MIN_RESOLUTION: "minResolution",
+  MAX_ZOOM: "maxZoom",
+  MIN_ZOOM: "minZoom",
+  SOURCE: "source",
+  MAP: "map"
+};
+export {
+  o as default
+};

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

@@ -0,0 +1,22 @@
+import r from "../renderer/canvas/TileLayer.mjs";
+import a from "./BaseTile.mjs";
+class t extends a {
+  /**
+   * @param {import("./BaseTile.js").Options<TileSourceType>} [options] Tile layer options.
+   */
+  constructor(e) {
+    super(e);
+  }
+  /**
+   * @override
+   */
+  createRenderer() {
+    return new r(this, {
+      cacheSize: this.getCacheSize()
+    });
+  }
+}
+const n = t;
+export {
+  n as default
+};

package/es/node_modules/.pnpm/ol@10.7.0/node_modules/ol/layer/TileProperty.mjs

@@ -0,0 +1,7 @@
+const e = {
+  PRELOAD: "preload",
+  USE_INTERIM_TILES_ON_ERROR: "useInterimTilesOnError"
+};
+export {
+  e as default
+};

package/es/node_modules/.pnpm/ol@10.7.0/node_modules/ol/layer/Vector.mjs

@@ -0,0 +1,20 @@
+import r from "../renderer/canvas/VectorLayer.mjs";
+import t from "./BaseVector.mjs";
+class o extends t {
+  /**
+   * @param {Options<VectorSourceType, FeatureType>} [options] Options.
+   */
+  constructor(e) {
+    super(e);
+  }
+  /**
+   * @override
+   */
+  createRenderer() {
+    return new r(this);
+  }
+}
+const n = o;
+export {
+  n as default
+};

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

@@ -0,0 +1,7 @@
+import "./proj.mjs";
+function e(n, i) {
+  return [[-1 / 0, -1 / 0, 1 / 0, 1 / 0]];
+}
+export {
+  e as all
+};

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

@@ -0,0 +1,88 @@
+function d(n, r, o) {
+  return Math.min(Math.max(n, r), o);
+}
+function h(n, r, o, t, u, c) {
+  const i = u - o, e = c - t;
+  if (i !== 0 || e !== 0) {
+    const f = ((n - o) * i + (r - t) * e) / (i * i + e * e);
+    f > 1 ? (o = u, t = c) : f > 0 && (o += i * f, t += e * f);
+  }
+  return a(n, r, o, t);
+}
+function a(n, r, o, t) {
+  const u = o - n, c = t - r;
+  return u * u + c * c;
+}
+function M(n) {
+  const r = n.length;
+  for (let t = 0; t < r; t++) {
+    let u = t, c = Math.abs(n[t][t]);
+    for (let e = t + 1; e < r; e++) {
+      const f = Math.abs(n[e][t]);
+      f > c && (c = f, u = e);
+    }
+    if (c === 0)
+      return null;
+    const i = n[u];
+    n[u] = n[t], n[t] = i;
+    for (let e = t + 1; e < r; e++) {
+      const f = -n[e][t] / n[t][t];
+      for (let s = t; s < r + 1; s++)
+        t == s ? n[e][s] = 0 : n[e][s] += f * n[t][s];
+    }
+  }
+  const o = new Array(r);
+  for (let t = r - 1; t >= 0; t--) {
+    o[t] = n[t][r] / n[t][t];
+    for (let u = t - 1; u >= 0; u--)
+      n[u][r] -= n[u][t] * o[t];
+  }
+  return o;
+}
+function p(n) {
+  return n * 180 / Math.PI;
+}
+function g(n) {
+  return n * Math.PI / 180;
+}
+function w(n, r) {
+  const o = n % r;
+  return o * r < 0 ? o + r : o;
+}
+function D(n, r, o) {
+  return n + o * (r - n);
+}
+function l(n, r) {
+  const o = Math.pow(10, r);
+  return Math.round(n * o) / o;
+}
+function q(n, r) {
+  return Math.round(l(n, r));
+}
+function I(n, r) {
+  return Math.floor(l(n, r));
+}
+function P(n, r) {
+  return Math.ceil(l(n, r));
+}
+function R(n, r, o) {
+  if (n >= r && n < o)
+    return n;
+  const t = o - r;
+  return ((n - r) % t + t) % t + r;
+}
+export {
+  P as ceil,
+  d as clamp,
+  I as floor,
+  D as lerp,
+  w as modulo,
+  q as round,
+  M as solveLinearSystem,
+  a as squaredDistance,
+  h as squaredSegmentDistance,
+  p as toDegrees,
+  l as toFixed,
+  g as toRadians,
+  R as wrap
+};

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

@@ -0,0 +1,14 @@
+function t(r) {
+  for (const e in r)
+    delete r[e];
+}
+function n(r) {
+  let e;
+  for (e in r)
+    return !1;
+  return !e;
+}
+export {
+  t as clear,
+  n as isEmpty
+};

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

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

package/es/node_modules/.pnpm/ol@10.7.0/node_modules/ol/pointer/EventType.mjs

@@ -0,0 +1,13 @@
+const e = {
+  POINTERMOVE: "pointermove",
+  POINTERDOWN: "pointerdown",
+  POINTERUP: "pointerup",
+  POINTEROVER: "pointerover",
+  POINTEROUT: "pointerout",
+  POINTERENTER: "pointerenter",
+  POINTERLEAVE: "pointerleave",
+  POINTERCANCEL: "pointercancel"
+};
+export {
+  e as default
+};

package/es/node_modules/.pnpm/ol@10.7.0/node_modules/ol/proj/Projection.mjs

@@ -0,0 +1,138 @@
+import { METERS_PER_UNIT as e } from "./Units.mjs";
+class i {
+  /**
+   * @param {Options} options Projection options.
+   */
+  constructor(t) {
+    this.code_ = t.code, this.units_ = /** @type {import("./Units.js").Units} */
+    t.units, this.extent_ = t.extent !== void 0 ? t.extent : null, this.worldExtent_ = t.worldExtent !== void 0 ? t.worldExtent : null, this.axisOrientation_ = t.axisOrientation !== void 0 ? t.axisOrientation : "enu", this.global_ = t.global !== void 0 ? t.global : !1, this.canWrapX_ = !!(this.global_ && this.extent_), this.getPointResolutionFunc_ = t.getPointResolution, this.defaultTileGrid_ = null, this.metersPerUnit_ = t.metersPerUnit;
+  }
+  /**
+   * @return {boolean} The projection is suitable for wrapping the x-axis
+   */
+  canWrapX() {
+    return this.canWrapX_;
+  }
+  /**
+   * Get the code for this projection, e.g. 'EPSG:4326'.
+   * @return {string} Code.
+   * @api
+   */
+  getCode() {
+    return this.code_;
+  }
+  /**
+   * Get the validity extent for this projection.
+   * @return {import("../extent.js").Extent} Extent.
+   * @api
+   */
+  getExtent() {
+    return this.extent_;
+  }
+  /**
+   * Get the units of this projection.
+   * @return {import("./Units.js").Units} Units.
+   * @api
+   */
+  getUnits() {
+    return this.units_;
+  }
+  /**
+   * Get the amount of meters per unit of this projection.  If the projection is
+   * not configured with `metersPerUnit` or a units identifier, the return is
+   * `undefined`.
+   * @return {number|undefined} Meters.
+   * @api
+   */
+  getMetersPerUnit() {
+    return this.metersPerUnit_ || e[this.units_];
+  }
+  /**
+   * Get the world extent for this projection.
+   * @return {import("../extent.js").Extent} Extent.
+   * @api
+   */
+  getWorldExtent() {
+    return this.worldExtent_;
+  }
+  /**
+   * Get the axis orientation of this projection.
+   * Example values are:
+   * enu - the default easting, northing, elevation.
+   * neu - northing, easting, up - useful for "lat/long" geographic coordinates,
+   *     or south orientated transverse mercator.
+   * wnu - westing, northing, up - some planetary coordinate systems have
+   *     "west positive" coordinate systems
+   * @return {string} Axis orientation.
+   * @api
+   */
+  getAxisOrientation() {
+    return this.axisOrientation_;
+  }
+  /**
+   * Is this projection a global projection which spans the whole world?
+   * @return {boolean} Whether the projection is global.
+   * @api
+   */
+  isGlobal() {
+    return this.global_;
+  }
+  /**
+   * Set if the projection is a global projection which spans the whole world
+   * @param {boolean} global Whether the projection is global.
+   * @api
+   */
+  setGlobal(t) {
+    this.global_ = t, this.canWrapX_ = !!(t && this.extent_);
+  }
+  /**
+   * @return {import("../tilegrid/TileGrid.js").default} The default tile grid.
+   */
+  getDefaultTileGrid() {
+    return this.defaultTileGrid_;
+  }
+  /**
+   * @param {import("../tilegrid/TileGrid.js").default} tileGrid The default tile grid.
+   */
+  setDefaultTileGrid(t) {
+    this.defaultTileGrid_ = t;
+  }
+  /**
+   * Set the validity extent for this projection.
+   * @param {import("../extent.js").Extent} extent Extent.
+   * @api
+   */
+  setExtent(t) {
+    this.extent_ = t, this.canWrapX_ = !!(this.global_ && t);
+  }
+  /**
+   * Set the world extent for this projection.
+   * @param {import("../extent.js").Extent} worldExtent World extent
+   *     [minlon, minlat, maxlon, maxlat].
+   * @api
+   */
+  setWorldExtent(t) {
+    this.worldExtent_ = t;
+  }
+  /**
+   * Set the getPointResolution function (see {@link module:ol/proj.getPointResolution}
+   * for this projection.
+   * @param {function(number, import("../coordinate.js").Coordinate):number} func Function
+   * @api
+   */
+  setGetPointResolution(t) {
+    this.getPointResolutionFunc_ = t;
+  }
+  /**
+   * Get the custom point resolution function for this projection (if set).
+   * @return {GetPointResolution|undefined} The custom point
+   * resolution function (if set).
+   */
+  getPointResolutionFunc() {
+    return this.getPointResolutionFunc_;
+  }
+}
+const s = i;
+export {
+  s as default
+};

package/es/node_modules/.pnpm/ol@10.7.0/node_modules/ol/proj/Units.mjs

@@ -0,0 +1,11 @@
+const t = {
+  // use the radius of the Normal sphere
+  radians: 6370997 / (2 * Math.PI),
+  degrees: 2 * Math.PI * 6370997 / 360,
+  ft: 0.3048,
+  m: 1,
+  "us-ft": 0.3048006096012192
+};
+export {
+  t as METERS_PER_UNIT
+};

package/es/node_modules/.pnpm/ol@10.7.0/node_modules/ol/proj/epsg3857.mjs

@@ -0,0 +1,54 @@
+import P from "./Projection.mjs";
+const f = 6378137, a = Math.PI * f, s = [-a, -a, a, a], w = [-180, -85, 180, 85], E = f * Math.log(Math.tan(Math.PI / 2));
+class r extends P {
+  /**
+   * @param {string} code Code.
+   */
+  constructor(e) {
+    super({
+      code: e,
+      units: "m",
+      extent: s,
+      global: !0,
+      worldExtent: w,
+      getPointResolution: function(t, l) {
+        return t / Math.cosh(l[1] / f);
+      }
+    });
+  }
+}
+const M = [
+  new r("EPSG:3857"),
+  new r("EPSG:102100"),
+  new r("EPSG:102113"),
+  new r("EPSG:900913"),
+  new r("http://www.opengis.net/def/crs/EPSG/0/3857"),
+  new r("http://www.opengis.net/gml/srs/epsg.xml#3857")
+];
+function S(c, e, t, l) {
+  const h = c.length;
+  t = t > 1 ? t : 2, l = l ?? t, e === void 0 && (t > 2 ? e = c.slice() : e = new Array(h));
+  for (let n = 0; n < h; n += l) {
+    e[n] = a * c[n] / 180;
+    let o = f * Math.log(Math.tan(Math.PI * (+c[n + 1] + 90) / 360));
+    o > E ? o = E : o < -E && (o = -E), e[n + 1] = o;
+  }
+  return e;
+}
+function G(c, e, t, l) {
+  const h = c.length;
+  t = t > 1 ? t : 2, l = l ?? t, e === void 0 && (t > 2 ? e = c.slice() : e = new Array(h));
+  for (let n = 0; n < h; n += l)
+    e[n] = 180 * c[n] / a, e[n + 1] = 360 * Math.atan(Math.exp(c[n + 1] / f)) / Math.PI - 90;
+  return e;
+}
+export {
+  s as EXTENT,
+  a as HALF_SIZE,
+  E as MAX_SAFE_Y,
+  M as PROJECTIONS,
+  f as RADIUS,
+  w as WORLD_EXTENT,
+  S as fromEPSG4326,
+  G as toEPSG4326
+};