gisviewer-vue3-arcgis 1.0.281 → 1.0.282

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

@@ -0,0 +1,195 @@
+import i from "./CollectionEventType.mjs";
+import u from "./Object.mjs";
+import c from "./events/Event.mjs";
+const n = {
+  LENGTH: "length"
+};
+class h extends c {
+  /**
+   * @param {import("./CollectionEventType.js").default} type Type.
+   * @param {T} element Element.
+   * @param {number} index The index of the added or removed element.
+   */
+  constructor(t, e, r) {
+    super(t), this.element = e, this.index = r;
+  }
+}
+class g extends u {
+  /**
+   * @param {Array<T>} [array] Array.
+   * @param {Options} [options] Collection options.
+   */
+  constructor(t, e) {
+    if (super(), this.on, this.once, this.un, e = e || {}, this.unique_ = !!e.unique, this.array_ = t ?? [], this.unique_)
+      for (let r = 1, s = this.array_.length; r < s; ++r)
+        this.assertUnique_(this.array_[r], r);
+    this.updateLength_();
+  }
+  /**
+   * Remove all elements from the collection.
+   * @api
+   */
+  clear() {
+    for (; this.getLength() > 0; )
+      this.pop();
+  }
+  /**
+   * Add elements to the collection.  This pushes each item in the provided array
+   * to the end of the collection.
+   * @param {!Array<T>} arr Array.
+   * @return {Collection<T>} This collection.
+   * @api
+   */
+  extend(t) {
+    for (let e = 0, r = t.length; e < r; ++e)
+      this.push(t[e]);
+    return this;
+  }
+  /**
+   * Iterate over each element, calling the provided callback.
+   * @param {function(T, number, Array<T>): *} f The function to call
+   *     for every element. This function takes 3 arguments (the element, the
+   *     index and the array). The return value is ignored.
+   * @api
+   */
+  forEach(t) {
+    const e = this.array_;
+    for (let r = 0, s = e.length; r < s; ++r)
+      t(e[r], r, e);
+  }
+  /**
+   * Get a reference to the underlying Array object. Warning: if the array
+   * is mutated, no events will be dispatched by the collection, and the
+   * collection's "length" property won't be in sync with the actual length
+   * of the array.
+   * @return {!Array<T>} Array.
+   * @api
+   */
+  getArray() {
+    return this.array_;
+  }
+  /**
+   * Get the element at the provided index.
+   * @param {number} index Index.
+   * @return {T} Element.
+   * @api
+   */
+  item(t) {
+    return this.array_[t];
+  }
+  /**
+   * Get the length of this collection.
+   * @return {number} The length of the array.
+   * @observable
+   * @api
+   */
+  getLength() {
+    return this.get(n.LENGTH);
+  }
+  /**
+   * Insert an element at the provided index.
+   * @param {number} index Index.
+   * @param {T} elem Element.
+   * @api
+   */
+  insertAt(t, e) {
+    if (t < 0 || t > this.getLength())
+      throw new Error("Index out of bounds: " + t);
+    this.unique_ && this.assertUnique_(e), this.array_.splice(t, 0, e), this.updateLength_(), this.dispatchEvent(
+      new h(i.ADD, e, t)
+    );
+  }
+  /**
+   * Remove the last element of the collection and return it.
+   * Return `undefined` if the collection is empty.
+   * @return {T|undefined} Element.
+   * @api
+   */
+  pop() {
+    return this.removeAt(this.getLength() - 1);
+  }
+  /**
+   * Insert the provided element at the end of the collection.
+   * @param {T} elem Element.
+   * @return {number} New length of the collection.
+   * @api
+   */
+  push(t) {
+    const e = this.getLength();
+    return this.insertAt(e, t), this.getLength();
+  }
+  /**
+   * Remove the first occurrence of an element from the collection.
+   * @param {T} elem Element.
+   * @return {T|undefined} The removed element or undefined if none found.
+   * @api
+   */
+  remove(t) {
+    const e = this.array_;
+    for (let r = 0, s = e.length; r < s; ++r)
+      if (e[r] === t)
+        return this.removeAt(r);
+  }
+  /**
+   * Remove the element at the provided index and return it.
+   * Return `undefined` if the collection does not contain this index.
+   * @param {number} index Index.
+   * @return {T|undefined} Value.
+   * @api
+   */
+  removeAt(t) {
+    if (t < 0 || t >= this.getLength())
+      return;
+    const e = this.array_[t];
+    return this.array_.splice(t, 1), this.updateLength_(), this.dispatchEvent(
+      /** @type {CollectionEvent<T>} */
+      new h(i.REMOVE, e, t)
+    ), e;
+  }
+  /**
+   * Set the element at the provided index.
+   * @param {number} index Index.
+   * @param {T} elem Element.
+   * @api
+   */
+  setAt(t, e) {
+    const r = this.getLength();
+    if (t >= r) {
+      this.insertAt(t, e);
+      return;
+    }
+    if (t < 0)
+      throw new Error("Index out of bounds: " + t);
+    this.unique_ && this.assertUnique_(e, t);
+    const s = this.array_[t];
+    this.array_[t] = e, this.dispatchEvent(
+      /** @type {CollectionEvent<T>} */
+      new h(i.REMOVE, s, t)
+    ), this.dispatchEvent(
+      /** @type {CollectionEvent<T>} */
+      new h(i.ADD, e, t)
+    );
+  }
+  /**
+   * @private
+   */
+  updateLength_() {
+    this.set(n.LENGTH, this.array_.length);
+  }
+  /**
+   * @private
+   * @param {T} elem Element.
+   * @param {number} [except] Optional index to ignore.
+   */
+  assertUnique_(t, e) {
+    const r = this.array_;
+    for (let s = 0, o = r.length; s < o; ++s)
+      if (r[s] === t && s !== e)
+        throw new Error("Duplicate item added to a unique collection");
+  }
+}
+const f = g;
+export {
+  h as CollectionEvent,
+  f as default
+};

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

@@ -0,0 +1,17 @@
+const e = {
+  /**
+   * Triggered when an item is added to the collection.
+   * @event module:ol/Collection.CollectionEvent#add
+   * @api
+   */
+  ADD: "add",
+  /**
+   * Triggered when an item is removed from the collection.
+   * @event module:ol/Collection.CollectionEvent#remove
+   * @api
+   */
+  REMOVE: "remove"
+};
+export {
+  e as default
+};

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

@@ -0,0 +1,73 @@
+import s from "./Tile.mjs";
+import r from "./TileState.mjs";
+function n(e) {
+  return e instanceof Image || e instanceof HTMLCanvasElement || e instanceof HTMLVideoElement || e instanceof ImageBitmap ? e : null;
+}
+const a = new Error("disposed"), o = [256, 256];
+class l extends s {
+  /**
+   * @param {Options} options Tile options.
+   */
+  constructor(t) {
+    const i = r.IDLE;
+    super(t.tileCoord, i, {
+      transition: t.transition,
+      interpolate: t.interpolate
+    }), this.loader_ = t.loader, this.data_ = null, this.error_ = null, this.size_ = t.size || null, this.controller_ = t.controller || null;
+  }
+  /**
+   * Get the tile size.
+   * @return {import('./size.js').Size} Tile size.
+   */
+  getSize() {
+    if (this.size_)
+      return this.size_;
+    const t = n(this.data_);
+    return t ? [t.width, t.height] : o;
+  }
+  /**
+   * Get the data for the tile.
+   * @return {Data} Tile data.
+   * @api
+   */
+  getData() {
+    return this.data_;
+  }
+  /**
+   * Get any loading error.
+   * @return {Error} Loading error.
+   * @api
+   */
+  getError() {
+    return this.error_;
+  }
+  /**
+   * Load the tile data.
+   * @api
+   * @override
+   */
+  load() {
+    if (this.state !== r.IDLE && this.state !== r.ERROR)
+      return;
+    this.state = r.LOADING, this.changed();
+    const t = this;
+    this.loader_().then(function(i) {
+      t.data_ = i, t.state = r.LOADED, t.changed();
+    }).catch(function(i) {
+      t.error_ = i, t.state = r.ERROR, t.changed();
+    });
+  }
+  /**
+   * Clean up.
+   * @override
+   */
+  disposeInternal() {
+    this.controller_ && (this.controller_.abort(a), this.controller_ = null), super.disposeInternal();
+  }
+}
+const u = l;
+export {
+  n as asImageLike,
+  u as default,
+  a as disposedError
+};

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

@@ -0,0 +1,21 @@
+class s {
+  constructor() {
+    this.disposed = !1;
+  }
+  /**
+   * Clean up.
+   */
+  dispose() {
+    this.disposed || (this.disposed = !0, this.disposeInternal());
+  }
+  /**
+   * Extension point for disposable objects.
+   * @protected
+   */
+  disposeInternal() {
+  }
+}
+const i = s;
+export {
+  i as default
+};

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

@@ -0,0 +1,181 @@
+import h from "./Object.mjs";
+import { assert as r } from "./asserts.mjs";
+import o from "./events/EventType.mjs";
+import { unlistenByKey as y, listen as a } from "./events.mjs";
+class n extends h {
+  /**
+   * @param {Geometry|ObjectWithGeometry<Geometry>} [geometryOrProperties]
+   *     You may pass a Geometry object directly, or an object literal containing
+   *     properties. If you pass an object literal, you may include a Geometry
+   *     associated with a `geometry` key.
+   */
+  constructor(e) {
+    if (super(), this.on, this.once, this.un, this.id_ = void 0, this.geometryName_ = "geometry", this.style_ = null, this.styleFunction_ = void 0, this.geometryChangeKey_ = null, this.addChangeListener(this.geometryName_, this.handleGeometryChanged_), e)
+      if (typeof /** @type {?} */
+      e.getSimplifiedGeometry == "function") {
+        const t = (
+          /** @type {Geometry} */
+          e
+        );
+        this.setGeometry(t);
+      } else {
+        const t = e;
+        this.setProperties(t);
+      }
+  }
+  /**
+   * Clone this feature. If the original feature has a geometry it
+   * is also cloned. The feature id is not set in the clone.
+   * @return {Feature<Geometry>} The clone.
+   * @api
+   */
+  clone() {
+    const e = (
+      /** @type {Feature<Geometry>} */
+      new n(this.hasProperties() ? this.getProperties() : null)
+    );
+    e.setGeometryName(this.getGeometryName());
+    const t = this.getGeometry();
+    t && e.setGeometry(
+      /** @type {Geometry} */
+      t.clone()
+    );
+    const i = this.getStyle();
+    return i && e.setStyle(i), e;
+  }
+  /**
+   * Get the feature's default geometry.  A feature may have any number of named
+   * geometries.  The "default" geometry (the one that is rendered by default) is
+   * set when calling {@link module:ol/Feature~Feature#setGeometry}.
+   * @return {Geometry|undefined} The default geometry for the feature.
+   * @api
+   * @observable
+   */
+  getGeometry() {
+    return (
+      /** @type {Geometry|undefined} */
+      this.get(this.geometryName_)
+    );
+  }
+  /**
+   * Get the feature identifier.  This is a stable identifier for the feature and
+   * is either set when reading data from a remote source or set explicitly by
+   * calling {@link module:ol/Feature~Feature#setId}.
+   * @return {number|string|undefined} Id.
+   * @api
+   */
+  getId() {
+    return this.id_;
+  }
+  /**
+   * Get the name of the feature's default geometry.  By default, the default
+   * geometry is named `geometry`.
+   * @return {string} Get the property name associated with the default geometry
+   *     for this feature.
+   * @api
+   */
+  getGeometryName() {
+    return this.geometryName_;
+  }
+  /**
+   * Get the feature's style. Will return what was provided to the
+   * {@link module:ol/Feature~Feature#setStyle} method.
+   * @return {import("./style/Style.js").StyleLike|undefined} The feature style.
+   * @api
+   */
+  getStyle() {
+    return this.style_;
+  }
+  /**
+   * Get the feature's style function.
+   * @return {import("./style/Style.js").StyleFunction|undefined} Return a function
+   * representing the current style of this feature.
+   * @api
+   */
+  getStyleFunction() {
+    return this.styleFunction_;
+  }
+  /**
+   * @private
+   */
+  handleGeometryChange_() {
+    this.changed();
+  }
+  /**
+   * @private
+   */
+  handleGeometryChanged_() {
+    this.geometryChangeKey_ && (y(this.geometryChangeKey_), this.geometryChangeKey_ = null);
+    const e = this.getGeometry();
+    e && (this.geometryChangeKey_ = a(
+      e,
+      o.CHANGE,
+      this.handleGeometryChange_,
+      this
+    )), this.changed();
+  }
+  /**
+   * Set the default geometry for the feature.  This will update the property
+   * with the name returned by {@link module:ol/Feature~Feature#getGeometryName}.
+   * @param {Geometry|undefined} geometry The new geometry.
+   * @api
+   * @observable
+   */
+  setGeometry(e) {
+    this.set(this.geometryName_, e);
+  }
+  /**
+   * Set the style for the feature to override the layer style.  This can be a
+   * single style object, an array of styles, or a function that takes a
+   * resolution and returns an array of styles. To unset the feature style, call
+   * `setStyle()` without arguments or a falsey value.
+   * @param {import("./style/Style.js").StyleLike} [style] Style for this feature.
+   * @api
+   * @fires module:ol/events/Event~BaseEvent#event:change
+   */
+  setStyle(e) {
+    this.style_ = e, this.styleFunction_ = e ? m(e) : void 0, this.changed();
+  }
+  /**
+   * Set the feature id.  The feature id is considered stable and may be used when
+   * requesting features or comparing identifiers returned from a remote source.
+   * The feature id can be used with the
+   * {@link module:ol/source/Vector~VectorSource#getFeatureById} method.
+   * @param {number|string|undefined} id The feature id.
+   * @api
+   * @fires module:ol/events/Event~BaseEvent#event:change
+   */
+  setId(e) {
+    this.id_ = e, this.changed();
+  }
+  /**
+   * Set the property name to be used when getting the feature's default geometry.
+   * When calling {@link module:ol/Feature~Feature#getGeometry}, the value of the property with
+   * this name will be returned.
+   * @param {string} name The property name of the default geometry.
+   * @api
+   */
+  setGeometryName(e) {
+    this.removeChangeListener(this.geometryName_, this.handleGeometryChanged_), this.geometryName_ = e, this.addChangeListener(this.geometryName_, this.handleGeometryChanged_), this.handleGeometryChanged_();
+  }
+}
+function m(s) {
+  if (typeof s == "function")
+    return s;
+  let e;
+  return Array.isArray(s) ? e = s : (r(
+    typeof /** @type {?} */
+    s.getZIndex == "function",
+    "Expected an `ol/style/Style` or an array of `ol/style/Style.js`"
+  ), e = [
+    /** @type {import("./style/Style.js").default} */
+    s
+  ]), function() {
+    return e;
+  };
+}
+const u = n;
+export {
+  m as createStyleFunction,
+  u as default
+};

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

@@ -0,0 +1,48 @@
+import s from "./events/EventType.mjs";
+import { listenOnce as u, unlistenByKey as E } from "./events.mjs";
+import { IMAGE_DECODE as l } from "./has.mjs";
+function w(e, n, o) {
+  const t = (
+    /** @type {HTMLImageElement} */
+    e
+  );
+  let r = !0, c = !1, i = !1;
+  const f = [
+    u(t, s.LOAD, function() {
+      i = !0, c || n();
+    })
+  ];
+  return t.src && l ? (c = !0, t.decode().then(function() {
+    r && n();
+  }).catch(function(d) {
+    r && (i ? n() : o());
+  })) : f.push(u(t, s.ERROR, o)), function() {
+    r = !1, f.forEach(E);
+  };
+}
+function h(e, n) {
+  return new Promise((o, t) => {
+    function r() {
+      i(), o(e);
+    }
+    function c() {
+      i(), t(new Error("Image load error"));
+    }
+    function i() {
+      e.removeEventListener("load", r), e.removeEventListener("error", c);
+    }
+    e.addEventListener("load", r), e.addEventListener("error", c), n && (e.src = n);
+  });
+}
+function y(e, n) {
+  return n && (e.src = n), e.src && l ? new Promise(
+    (o, t) => e.decode().then(() => o(e)).catch(
+      (r) => e.complete && e.width ? o(e) : t(r)
+    )
+  ) : h(e);
+}
+export {
+  y as decodeFallback,
+  w as listenImage,
+  h as load
+};

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

@@ -0,0 +1,10 @@
+const t = {
+  IDLE: 0,
+  LOADING: 1,
+  LOADED: 2,
+  ERROR: 3,
+  EMPTY: 4
+};
+export {
+  t as default
+};

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

@@ -0,0 +1,131 @@
+import { listenImage as g } from "./Image.mjs";
+import m from "./Tile.mjs";
+import t from "./TileState.mjs";
+import { createCanvasContext2D as _ } from "./dom.mjs";
+import { WORKER_OFFSCREEN_CANVAS as n } from "./has.mjs";
+class o extends m {
+  /**
+   * @param {import("./tilecoord.js").TileCoord} tileCoord Tile coordinate.
+   * @param {import("./TileState.js").default} state State.
+   * @param {string} src Image source URI.
+   * @param {?string} crossOrigin Cross origin.
+   * @param {import("./Tile.js").LoadFunction} tileLoadFunction Tile load function.
+   * @param {import("./Tile.js").Options} [options] Tile options.
+   */
+  constructor(i, h, a, e, l, r) {
+    super(i, h, r), this.crossOrigin_ = e, this.src_ = a, this.key = a, this.image_, n ? this.image_ = new OffscreenCanvas(1, 1) : (this.image_ = new Image(), e !== null && (this.image_.crossOrigin = e)), this.unlisten_ = null, this.tileLoadFunction_ = l;
+  }
+  /**
+   * Get the HTML image element for this tile (may be a Canvas, OffscreenCanvas, Image, or Video).
+   * @return {HTMLCanvasElement|OffscreenCanvas|HTMLImageElement|HTMLVideoElement} Image.
+   * @api
+   */
+  getImage() {
+    return this.image_;
+  }
+  /**
+   * Sets an HTML image element for this tile (may be a Canvas or preloaded Image).
+   * @param {HTMLCanvasElement|OffscreenCanvas|HTMLImageElement} element Element.
+   */
+  setImage(i) {
+    this.image_ = i, this.state = t.LOADED, this.unlistenImage_(), this.changed();
+  }
+  /**
+   * Get the cross origin of the ImageTile.
+   * @return {string} Cross origin.
+   */
+  getCrossOrigin() {
+    return this.crossOrigin_;
+  }
+  /**
+   * Tracks loading or read errors.
+   *
+   * @private
+   */
+  handleImageError_() {
+    this.state = t.ERROR, this.unlistenImage_(), this.image_ = u(), this.changed();
+  }
+  /**
+   * Tracks successful image load.
+   *
+   * @private
+   */
+  handleImageLoad_() {
+    if (n)
+      this.state = t.LOADED;
+    else {
+      const i = (
+        /** @type {HTMLImageElement} */
+        this.image_
+      );
+      i.naturalWidth && i.naturalHeight ? this.state = t.LOADED : this.state = t.EMPTY;
+    }
+    this.unlistenImage_(), 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.
+   *
+   * To retry loading tiles on failed requests, use a custom `tileLoadFunction`
+   * that checks for error status codes and reloads only when the status code is
+   * 408, 429, 500, 502, 503 and 504, and only when not too many retries have been
+   * made already:
+   *
+   * ```js
+   * const retryCodes = [408, 429, 500, 502, 503, 504];
+   * const retries = {};
+   * source.setTileLoadFunction((tile, src) => {
+   *   const image = tile.getImage();
+   *   fetch(src)
+   *     .then((response) => {
+   *       if (retryCodes.includes(response.status)) {
+   *         retries[src] = (retries[src] || 0) + 1;
+   *         if (retries[src] <= 3) {
+   *           setTimeout(() => tile.load(), retries[src] * 1000);
+   *         }
+   *         return Promise.reject();
+   *       }
+   *       return response.blob();
+   *     })
+   *     .then((blob) => {
+   *       const imageUrl = URL.createObjectURL(blob);
+   *       image.src = imageUrl;
+   *       setTimeout(() => URL.revokeObjectURL(imageUrl), 5000);
+   *     })
+   *     .catch(() => tile.setState(3)); // error
+   * });
+   * ```
+   * @api
+   * @override
+   */
+  load() {
+    this.state == t.ERROR && (this.state = t.IDLE, this.image_ = new Image(), this.crossOrigin_ !== null && (this.image_.crossOrigin = this.crossOrigin_)), this.state == t.IDLE && (this.state = t.LOADING, this.changed(), this.tileLoadFunction_(this, this.src_), this.unlisten_ = g(
+      this.image_,
+      this.handleImageLoad_.bind(this),
+      this.handleImageError_.bind(this)
+    ));
+  }
+  /**
+   * Discards event handlers which listen for load completion or errors.
+   *
+   * @private
+   */
+  unlistenImage_() {
+    this.unlisten_ && (this.unlisten_(), this.unlisten_ = null);
+  }
+  /**
+   * @override
+   */
+  disposeInternal() {
+    this.unlistenImage_(), this.image_ = null, super.disposeInternal();
+  }
+}
+function u() {
+  const s = _(1, 1);
+  return s.fillStyle = "rgba(0,0,0,0)", s.fillRect(0, 0, 1, 1), s.canvas;
+}
+const E = o;
+export {
+  E as default
+};