gisviewer-vue3-arcgis 1.0.281 → 1.0.282

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

@@ -0,0 +1,59 @@
+import s from "./MapEvent.mjs";
+class a extends s {
+  /**
+   * @param {string} type Event type.
+   * @param {import("./Map.js").default} map Map.
+   * @param {EVENT} originalEvent Original event.
+   * @param {boolean} [dragging] Is the map currently being dragged?
+   * @param {import("./Map.js").FrameState} [frameState] Frame state.
+   * @param {Array<PointerEvent>} [activePointers] Active pointers.
+   */
+  constructor(t, e, n, i, o, r) {
+    super(t, e, o), this.originalEvent = n, this.pixel_ = null, this.coordinate_ = null, this.dragging = i !== void 0 ? i : !1, this.activePointers = r;
+  }
+  /**
+   * The map pixel relative to the viewport corresponding to the original event.
+   * @type {import("./pixel.js").Pixel}
+   * @api
+   */
+  get pixel() {
+    return this.pixel_ || (this.pixel_ = this.map.getEventPixel(this.originalEvent)), this.pixel_;
+  }
+  set pixel(t) {
+    this.pixel_ = t;
+  }
+  /**
+   * The coordinate corresponding to the original browser event.  This will be in the user
+   * projection if one is set.  Otherwise it will be in the view projection.
+   * @type {import("./coordinate.js").Coordinate}
+   * @api
+   */
+  get coordinate() {
+    return this.coordinate_ || (this.coordinate_ = this.map.getCoordinateFromPixel(this.pixel)), this.coordinate_;
+  }
+  set coordinate(t) {
+    this.coordinate_ = t;
+  }
+  /**
+   * Prevents the default browser action.
+   * See https://developer.mozilla.org/en-US/docs/Web/API/event.preventDefault.
+   * @api
+   * @override
+   */
+  preventDefault() {
+    super.preventDefault(), "preventDefault" in this.originalEvent && this.originalEvent.preventDefault();
+  }
+  /**
+   * Prevents further propagation of the current event.
+   * See https://developer.mozilla.org/en-US/docs/Web/API/event.stopPropagation.
+   * @api
+   * @override
+   */
+  stopPropagation() {
+    super.stopPropagation(), "stopPropagation" in this.originalEvent && this.originalEvent.stopPropagation();
+  }
+}
+const h = a;
+export {
+  h as default
+};

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

@@ -0,0 +1,232 @@
+import n from "./MapBrowserEvent.mjs";
+import i from "./MapBrowserEventType.mjs";
+import a from "./events/EventType.mjs";
+import _ from "./events/Target.mjs";
+import { listen as h, unlistenByKey as o } from "./events.mjs";
+import { PASSIVE_EVENT_LISTENERS as l } from "./has.mjs";
+import d from "./pointer/EventType.mjs";
+class c extends _ {
+  /**
+   * @param {import("./Map.js").default} map The map with the viewport to listen to events on.
+   * @param {number} [moveTolerance] The minimal distance the pointer must travel to trigger a move.
+   */
+  constructor(e, t) {
+    super(e), this.map_ = e, this.clickTimeoutId_, this.emulateClicks_ = !1, this.dragging_ = !1, this.dragListenerKeys_ = [], this.moveTolerance_ = t === void 0 ? 1 : t, this.down_ = null;
+    const s = this.map_.getViewport();
+    this.activePointers_ = [], this.trackedTouches_ = {}, this.element_ = s, this.pointerdownListenerKey_ = h(
+      s,
+      d.POINTERDOWN,
+      this.handlePointerDown_,
+      this
+    ), this.originalPointerMoveEvent_, this.relayedListenerKey_ = h(
+      s,
+      d.POINTERMOVE,
+      this.relayMoveEvent_,
+      this
+    ), this.boundHandleTouchMove_ = this.handleTouchMove_.bind(this), this.element_.addEventListener(
+      a.TOUCHMOVE,
+      this.boundHandleTouchMove_,
+      l ? { passive: !1 } : !1
+    );
+  }
+  /**
+   * @param {PointerEvent} pointerEvent Pointer
+   * event.
+   * @private
+   */
+  emulateClick_(e) {
+    let t = new n(
+      i.CLICK,
+      this.map_,
+      e
+    );
+    this.dispatchEvent(t), this.clickTimeoutId_ !== void 0 ? (clearTimeout(this.clickTimeoutId_), this.clickTimeoutId_ = void 0, t = new n(
+      i.DBLCLICK,
+      this.map_,
+      e
+    ), this.dispatchEvent(t)) : this.clickTimeoutId_ = setTimeout(() => {
+      this.clickTimeoutId_ = void 0;
+      const s = new n(
+        i.SINGLECLICK,
+        this.map_,
+        e
+      );
+      this.dispatchEvent(s);
+    }, 250);
+  }
+  /**
+   * Keeps track on how many pointers are currently active.
+   *
+   * @param {PointerEvent} pointerEvent Pointer
+   * event.
+   * @private
+   */
+  updateActivePointers_(e) {
+    const t = e, s = t.pointerId;
+    if (t.type == i.POINTERUP || t.type == i.POINTERCANCEL) {
+      delete this.trackedTouches_[s];
+      for (const r in this.trackedTouches_)
+        if (this.trackedTouches_[r].target !== t.target) {
+          delete this.trackedTouches_[r];
+          break;
+        }
+    } else
+      (t.type == i.POINTERDOWN || t.type == i.POINTERMOVE) && (this.trackedTouches_[s] = t);
+    this.activePointers_ = Object.values(this.trackedTouches_);
+  }
+  /**
+   * @param {PointerEvent} pointerEvent Pointer
+   * event.
+   * @private
+   */
+  handlePointerUp_(e) {
+    this.updateActivePointers_(e);
+    const t = new n(
+      i.POINTERUP,
+      this.map_,
+      e,
+      void 0,
+      void 0,
+      this.activePointers_
+    );
+    this.dispatchEvent(t), this.emulateClicks_ && !t.defaultPrevented && !this.dragging_ && this.isMouseActionButton_(e) && this.emulateClick_(this.down_), this.activePointers_.length === 0 && (this.dragListenerKeys_.forEach(o), this.dragListenerKeys_.length = 0, this.dragging_ = !1, this.down_ = null);
+  }
+  /**
+   * @param {PointerEvent} pointerEvent Pointer
+   * event.
+   * @return {boolean} If the left mouse button was pressed.
+   * @private
+   */
+  isMouseActionButton_(e) {
+    return e.button === 0;
+  }
+  /**
+   * @param {PointerEvent} pointerEvent Pointer
+   * event.
+   * @private
+   */
+  handlePointerDown_(e) {
+    this.emulateClicks_ = this.activePointers_.length === 0, this.updateActivePointers_(e);
+    const t = new n(
+      i.POINTERDOWN,
+      this.map_,
+      e,
+      void 0,
+      void 0,
+      this.activePointers_
+    );
+    if (this.dispatchEvent(t), this.down_ = new PointerEvent(e.type, e), Object.defineProperty(this.down_, "target", {
+      writable: !1,
+      value: e.target
+    }), this.dragListenerKeys_.length === 0) {
+      const s = this.map_.getOwnerDocument();
+      this.dragListenerKeys_.push(
+        h(
+          s,
+          i.POINTERMOVE,
+          this.handlePointerMove_,
+          this
+        ),
+        h(s, i.POINTERUP, this.handlePointerUp_, this),
+        /* Note that the listener for `pointercancel is set up on
+         * `pointerEventHandler_` and not `documentPointerEventHandler_` like
+         * the `pointerup` and `pointermove` listeners.
+         *
+         * The reason for this is the following: `TouchSource.vacuumTouches_()`
+         * issues `pointercancel` events, when there was no `touchend` for a
+         * `touchstart`. Now, let's say a first `touchstart` is registered on
+         * `pointerEventHandler_`. The `documentPointerEventHandler_` is set up.
+         * But `documentPointerEventHandler_` doesn't know about the first
+         * `touchstart`. If there is no `touchend` for the `touchstart`, we can
+         * only receive a `touchcancel` from `pointerEventHandler_`, because it is
+         * only registered there.
+         */
+        h(
+          this.element_,
+          i.POINTERCANCEL,
+          this.handlePointerUp_,
+          this
+        )
+      ), this.element_.getRootNode && this.element_.getRootNode() !== s && this.dragListenerKeys_.push(
+        h(
+          this.element_.getRootNode(),
+          i.POINTERUP,
+          this.handlePointerUp_,
+          this
+        )
+      );
+    }
+  }
+  /**
+   * @param {PointerEvent} pointerEvent Pointer
+   * event.
+   * @private
+   */
+  handlePointerMove_(e) {
+    if (this.isMoving_(e)) {
+      this.updateActivePointers_(e), this.dragging_ = !0;
+      const t = new n(
+        i.POINTERDRAG,
+        this.map_,
+        e,
+        this.dragging_,
+        void 0,
+        this.activePointers_
+      );
+      this.dispatchEvent(t);
+    }
+  }
+  /**
+   * Wrap and relay a pointermove event.
+   * @param {PointerEvent} pointerEvent Pointer
+   * event.
+   * @private
+   */
+  relayMoveEvent_(e) {
+    this.originalPointerMoveEvent_ = e;
+    const t = !!(this.down_ && this.isMoving_(e));
+    this.dispatchEvent(
+      new n(
+        i.POINTERMOVE,
+        this.map_,
+        e,
+        t
+      )
+    );
+  }
+  /**
+   * Flexible handling of a `touch-action: none` css equivalent: because calling
+   * `preventDefault()` on a `pointermove` event does not stop native page scrolling
+   * and zooming, we also listen for `touchmove` and call `preventDefault()` on it
+   * when an interaction (currently `DragPan` handles the event.
+   * @param {TouchEvent} event Event.
+   * @private
+   */
+  handleTouchMove_(e) {
+    const t = this.originalPointerMoveEvent_;
+    (!t || t.defaultPrevented) && (typeof e.cancelable != "boolean" || e.cancelable === !0) && e.preventDefault();
+  }
+  /**
+   * @param {PointerEvent} pointerEvent Pointer
+   * event.
+   * @return {boolean} Is moving.
+   * @private
+   */
+  isMoving_(e) {
+    return this.dragging_ || Math.abs(e.clientX - this.down_.clientX) > this.moveTolerance_ || Math.abs(e.clientY - this.down_.clientY) > this.moveTolerance_;
+  }
+  /**
+   * Clean up.
+   * @override
+   */
+  disposeInternal() {
+    this.relayedListenerKey_ && (o(this.relayedListenerKey_), this.relayedListenerKey_ = null), this.element_.removeEventListener(
+      a.TOUCHMOVE,
+      this.boundHandleTouchMove_
+    ), this.pointerdownListenerKey_ && (o(this.pointerdownListenerKey_), this.pointerdownListenerKey_ = null), this.dragListenerKeys_.forEach(o), this.dragListenerKeys_.length = 0, this.element_ = null, super.disposeInternal();
+  }
+}
+const f = c;
+export {
+  f as default
+};

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

@@ -0,0 +1,45 @@
+import e from "./events/EventType.mjs";
+const o = {
+  /**
+   * A true single click with no dragging and no double click. Note that this
+   * event is delayed by 250 ms to ensure that it is not a double click.
+   * @event module:ol/MapBrowserEvent~MapBrowserEvent#singleclick
+   * @api
+   */
+  SINGLECLICK: "singleclick",
+  /**
+   * A click with no dragging. A double click will fire two of this.
+   * @event module:ol/MapBrowserEvent~MapBrowserEvent#click
+   * @api
+   */
+  CLICK: e.CLICK,
+  /**
+   * A true double click, with no dragging.
+   * @event module:ol/MapBrowserEvent~MapBrowserEvent#dblclick
+   * @api
+   */
+  DBLCLICK: e.DBLCLICK,
+  /**
+   * Triggered when a pointer is dragged.
+   * @event module:ol/MapBrowserEvent~MapBrowserEvent#pointerdrag
+   * @api
+   */
+  POINTERDRAG: "pointerdrag",
+  /**
+   * Triggered when a pointer is moved. Note that on touch devices this is
+   * triggered when the map is panned, so is not the same as mousemove.
+   * @event module:ol/MapBrowserEvent~MapBrowserEvent#pointermove
+   * @api
+   */
+  POINTERMOVE: "pointermove",
+  POINTERDOWN: "pointerdown",
+  POINTERUP: "pointerup",
+  POINTEROVER: "pointerover",
+  POINTEROUT: "pointerout",
+  POINTERENTER: "pointerenter",
+  POINTERLEAVE: "pointerleave",
+  POINTERCANCEL: "pointercancel"
+};
+export {
+  o as default
+};

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

@@ -0,0 +1,15 @@
+import s from "./events/Event.mjs";
+class a extends s {
+  /**
+   * @param {string} type Event type.
+   * @param {import("./Map.js").default} map Map.
+   * @param {?import("./Map.js").FrameState} [frameState] Frame state.
+   */
+  constructor(e, n, t) {
+    super(e), this.map = n, this.frameState = t !== void 0 ? t : null;
+  }
+}
+const r = a;
+export {
+  r as default
+};

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

@@ -0,0 +1,35 @@
+const e = {
+  /**
+   * Triggered after a map frame is rendered.
+   * @event module:ol/MapEvent~MapEvent#postrender
+   * @api
+   */
+  POSTRENDER: "postrender",
+  /**
+   * Triggered when the map starts moving.
+   * @event module:ol/MapEvent~MapEvent#movestart
+   * @api
+   */
+  MOVESTART: "movestart",
+  /**
+   * Triggered after the map is moved.
+   * @event module:ol/MapEvent~MapEvent#moveend
+   * @api
+   */
+  MOVEEND: "moveend",
+  /**
+   * Triggered when loading of additional map data (tiles, images, features) starts.
+   * @event module:ol/MapEvent~MapEvent#loadstart
+   * @api
+   */
+  LOADSTART: "loadstart",
+  /**
+   * Triggered when loading of additional map data has completed.
+   * @event module:ol/MapEvent~MapEvent#loadend
+   * @api
+   */
+  LOADEND: "loadend"
+};
+export {
+  e as default
+};

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

@@ -0,0 +1,9 @@
+const e = {
+  LAYERGROUP: "layergroup",
+  SIZE: "size",
+  TARGET: "target",
+  VIEW: "view"
+};
+export {
+  e as default
+};

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

@@ -0,0 +1,136 @@
+import a from "./ObjectEventType.mjs";
+import l from "./Observable.mjs";
+import u from "./events/Event.mjs";
+import { isEmpty as o } from "./obj.mjs";
+import { getUid as v } from "./util.mjs";
+class r extends u {
+  /**
+   * @param {string} type The event type.
+   * @param {string} key The property name.
+   * @param {*} oldValue The old value for `key`.
+   */
+  constructor(e, t, s) {
+    super(e), this.key = t, this.oldValue = s;
+  }
+}
+class c extends l {
+  /**
+   * @param {Object<string, *>} [values] An object with key-value pairs.
+   */
+  constructor(e) {
+    super(), this.on, this.once, this.un, v(this), this.values_ = null, e !== void 0 && this.setProperties(e);
+  }
+  /**
+   * Gets a value.
+   * @param {string} key Key name.
+   * @return {*} Value.
+   * @api
+   */
+  get(e) {
+    let t;
+    return this.values_ && this.values_.hasOwnProperty(e) && (t = this.values_[e]), t;
+  }
+  /**
+   * Get a list of object property names.
+   * @return {Array<string>} List of property names.
+   * @api
+   */
+  getKeys() {
+    return this.values_ && Object.keys(this.values_) || [];
+  }
+  /**
+   * Get an object of all property names and values.
+   * @return {Object<string, *>} Object.
+   * @api
+   */
+  getProperties() {
+    return this.values_ && Object.assign({}, this.values_) || {};
+  }
+  /**
+   * Get an object of all property names and values.
+   * @return {Object<string, *>?} Object.
+   */
+  getPropertiesInternal() {
+    return this.values_;
+  }
+  /**
+   * @return {boolean} The object has properties.
+   */
+  hasProperties() {
+    return !!this.values_;
+  }
+  /**
+   * @param {string} key Key name.
+   * @param {*} oldValue Old value.
+   */
+  notify(e, t) {
+    let s;
+    s = `change:${e}`, this.hasListener(s) && this.dispatchEvent(new r(s, e, t)), s = a.PROPERTYCHANGE, this.hasListener(s) && this.dispatchEvent(new r(s, e, t));
+  }
+  /**
+   * @param {string} key Key name.
+   * @param {import("./events.js").Listener} listener Listener.
+   */
+  addChangeListener(e, t) {
+    this.addEventListener(`change:${e}`, t);
+  }
+  /**
+   * @param {string} key Key name.
+   * @param {import("./events.js").Listener} listener Listener.
+   */
+  removeChangeListener(e, t) {
+    this.removeEventListener(`change:${e}`, t);
+  }
+  /**
+   * Sets a value.
+   * @param {string} key Key name.
+   * @param {*} value Value.
+   * @param {boolean} [silent] Update without triggering an event.
+   * @api
+   */
+  set(e, t, s) {
+    const i = this.values_ || (this.values_ = {});
+    if (s)
+      i[e] = t;
+    else {
+      const n = i[e];
+      i[e] = t, n !== t && this.notify(e, n);
+    }
+  }
+  /**
+   * Sets a collection of key-value pairs.  Note that this changes any existing
+   * properties and adds new ones (it does not remove any existing properties).
+   * @param {Object<string, *>} values Values.
+   * @param {boolean} [silent] Update without triggering an event.
+   * @api
+   */
+  setProperties(e, t) {
+    for (const s in e)
+      this.set(s, e[s], t);
+  }
+  /**
+   * Apply any properties from another object without triggering events.
+   * @param {BaseObject} source The source object.
+   * @protected
+   */
+  applyProperties(e) {
+    e.values_ && Object.assign(this.values_ || (this.values_ = {}), e.values_);
+  }
+  /**
+   * Unsets a property.
+   * @param {string} key Key name.
+   * @param {boolean} [silent] Unset without triggering an event.
+   * @api
+   */
+  unset(e, t) {
+    if (this.values_ && e in this.values_) {
+      const s = this.values_[e];
+      delete this.values_[e], o(this.values_) && (this.values_ = null), t || this.notify(e, s);
+    }
+  }
+}
+const g = c;
+export {
+  r as ObjectEvent,
+  g as default
+};

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

@@ -0,0 +1,11 @@
+const e = {
+  /**
+   * Triggered when a property is changed.
+   * @event module:ol/Object.ObjectEvent#propertychange
+   * @api
+   */
+  PROPERTYCHANGE: "propertychange"
+};
+export {
+  e as default
+};

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

@@ -0,0 +1,105 @@
+import c from "./events/EventType.mjs";
+import f from "./events/Target.mjs";
+import { unlistenByKey as l, listen as a, listenOnce as h } from "./events.mjs";
+class o extends f {
+  constructor() {
+    super(), this.on = /** @type {ObservableOnSignature<import("./events").EventsKey>} */
+    this.onInternal, this.once = /** @type {ObservableOnSignature<import("./events").EventsKey>} */
+    this.onceInternal, this.un = /** @type {ObservableOnSignature<void>} */
+    this.unInternal, this.revision_ = 0;
+  }
+  /**
+   * Increases the revision counter and dispatches a 'change' event.
+   * @api
+   */
+  changed() {
+    ++this.revision_, this.dispatchEvent(c.CHANGE);
+  }
+  /**
+   * Get the version number for this object.  Each time the object is modified,
+   * its version number will be incremented.
+   * @return {number} Revision.
+   * @api
+   */
+  getRevision() {
+    return this.revision_;
+  }
+  /**
+   * @param {string|Array<string>} type Type.
+   * @param {function((Event|import("./events/Event").default)): ?} listener Listener.
+   * @return {import("./events.js").EventsKey|Array<import("./events.js").EventsKey>} Event key.
+   * @protected
+   */
+  onInternal(n, e) {
+    if (Array.isArray(n)) {
+      const r = n.length, i = new Array(r);
+      for (let t = 0; t < r; ++t)
+        i[t] = a(this, n[t], e);
+      return i;
+    }
+    return a(
+      this,
+      /** @type {string} */
+      n,
+      e
+    );
+  }
+  /**
+   * @param {string|Array<string>} type Type.
+   * @param {function((Event|import("./events/Event").default)): ?} listener Listener.
+   * @return {import("./events.js").EventsKey|Array<import("./events.js").EventsKey>} Event key.
+   * @protected
+   */
+  onceInternal(n, e) {
+    let r;
+    if (Array.isArray(n)) {
+      const i = n.length;
+      r = new Array(i);
+      for (let t = 0; t < i; ++t)
+        r[t] = h(this, n[t], e);
+    } else
+      r = h(
+        this,
+        /** @type {string} */
+        n,
+        e
+      );
+    return e.ol_key = r, r;
+  }
+  /**
+   * Unlisten for a certain type of event.
+   * @param {string|Array<string>} type Type.
+   * @param {function((Event|import("./events/Event").default)): ?} listener Listener.
+   * @protected
+   */
+  unInternal(n, e) {
+    const r = (
+      /** @type {Object} */
+      e.ol_key
+    );
+    if (r)
+      u(r);
+    else if (Array.isArray(n))
+      for (let i = 0, t = n.length; i < t; ++i)
+        this.removeEventListener(n[i], e);
+    else
+      this.removeEventListener(n, e);
+  }
+}
+o.prototype.on;
+o.prototype.once;
+o.prototype.un;
+function u(s) {
+  if (Array.isArray(s))
+    for (let n = 0, e = s.length; n < e; ++n)
+      l(s[n]);
+  else
+    l(
+      /** @type {import("./events.js").EventsKey} */
+      s
+    );
+}
+export {
+  o as default,
+  u as unByKey
+};