gisviewer-vue3-arcgis 1.0.281 → 1.0.283

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

@@ -0,0 +1,87 @@
+import i from "./Layer.mjs";
+import r from "./TileProperty.mjs";
+class a extends i {
+  /**
+   * @param {Options<TileSourceType>} [options] Tile layer options.
+   */
+  constructor(e) {
+    e = e || {};
+    const t = Object.assign({}, e), s = e.cacheSize;
+    delete e.cacheSize, delete t.preload, delete t.useInterimTilesOnError, super(t), this.on, this.once, this.un, this.cacheSize_ = s, this.setPreload(e.preload !== void 0 ? e.preload : 0), this.setUseInterimTilesOnError(
+      e.useInterimTilesOnError !== void 0 ? e.useInterimTilesOnError : !0
+    );
+  }
+  /**
+   * @return {number|undefined} The suggested cache size
+   * @protected
+   */
+  getCacheSize() {
+    return this.cacheSize_;
+  }
+  /**
+   * Return the level as number to which we will preload tiles up to.
+   * @return {number} The level to preload tiles up to.
+   * @observable
+   * @api
+   */
+  getPreload() {
+    return (
+      /** @type {number} */
+      this.get(r.PRELOAD)
+    );
+  }
+  /**
+   * Set the level as number to which we will preload tiles up to.
+   * @param {number} preload The level to preload tiles up to.
+   * @observable
+   * @api
+   */
+  setPreload(e) {
+    this.set(r.PRELOAD, e);
+  }
+  /**
+   * Deprecated.  Whether we use interim tiles on error.
+   * @return {boolean} Use interim tiles on error.
+   * @observable
+   * @api
+   */
+  getUseInterimTilesOnError() {
+    return (
+      /** @type {boolean} */
+      this.get(r.USE_INTERIM_TILES_ON_ERROR)
+    );
+  }
+  /**
+   * Deprecated.  Set whether we use interim tiles on error.
+   * @param {boolean} useInterimTilesOnError Use interim tiles on error.
+   * @observable
+   * @api
+   */
+  setUseInterimTilesOnError(e) {
+    this.set(r.USE_INTERIM_TILES_ON_ERROR, e);
+  }
+  /**
+   * Get data for a pixel location.  The return type depends on the source data.  For image tiles,
+   * a four element RGBA array will be returned.  For data tiles, the array length will match the
+   * number of bands in the dataset.  For requests outside the layer extent, `null` will be returned.
+   * Data for a image tiles can only be retrieved if the source's `crossOrigin` property is set.
+   *
+   * ```js
+   * // display layer data on every pointer move
+   * map.on('pointermove', (event) => {
+   *   console.log(layer.getData(event.pixel));
+   * });
+   * ```
+   * @param {import("../pixel").Pixel} pixel Pixel.
+   * @return {Uint8ClampedArray|Uint8Array|Float32Array|DataView|null} Pixel data.
+   * @api
+   * @override
+   */
+  getData(e) {
+    return super.getData(e);
+  }
+}
+const h = a;
+export {
+  h as default
+};

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

@@ -0,0 +1,179 @@
+import f from "../../../../rbush@4.0.1/node_modules/rbush/index.mjs";
+import { flatStylesToStyleFunction as s, rulesToStyleFunction as h } from "../render/canvas/style.mjs";
+import l, { createDefaultStyle as c, toFunction as g } from "../style/Style.mjs";
+import o from "./Layer.mjs";
+const a = {
+  RENDER_ORDER: "renderOrder"
+};
+class y extends o {
+  /**
+   * @param {Options<FeatureType, VectorSourceType>} [options] Options.
+   */
+  constructor(e) {
+    e = e || {};
+    const r = Object.assign({}, e);
+    delete r.style, delete r.renderBuffer, delete r.updateWhileAnimating, delete r.updateWhileInteracting, super(r), this.declutter_ = e.declutter ? String(e.declutter) : void 0, this.renderBuffer_ = e.renderBuffer !== void 0 ? e.renderBuffer : 100, this.style_ = null, this.styleFunction_ = void 0, this.setStyle(e.style), this.updateWhileAnimating_ = e.updateWhileAnimating !== void 0 ? e.updateWhileAnimating : !1, this.updateWhileInteracting_ = e.updateWhileInteracting !== void 0 ? e.updateWhileInteracting : !1;
+  }
+  /**
+   * @return {string} Declutter group.
+   * @override
+   */
+  getDeclutter() {
+    return this.declutter_;
+  }
+  /**
+   * Get the topmost feature that intersects the given pixel on the viewport. Returns a promise
+   * that resolves with an array of features. The array will either contain the topmost feature
+   * when a hit was detected, or it will be empty.
+   *
+   * The hit detection algorithm used for this method is optimized for performance, but is less
+   * accurate than the one used in [map.getFeaturesAtPixel()]{@link import("../Map.js").default#getFeaturesAtPixel}.
+   * Text is not considered, and icons are only represented by their bounding box instead of the exact
+   * image.
+   *
+   * @param {import("../pixel.js").Pixel} pixel Pixel.
+   * @return {Promise<Array<import("../Feature").FeatureLike>>} Promise that resolves with an array of features.
+   * @api
+   * @override
+   */
+  getFeatures(e) {
+    return super.getFeatures(e);
+  }
+  /**
+   * @return {number|undefined} Render buffer.
+   */
+  getRenderBuffer() {
+    return this.renderBuffer_;
+  }
+  /**
+   * @return {import("../render.js").OrderFunction|null|undefined} Render order.
+   */
+  getRenderOrder() {
+    return (
+      /** @type {import("../render.js").OrderFunction|null|undefined} */
+      this.get(a.RENDER_ORDER)
+    );
+  }
+  /**
+   * Get the style for features.  This returns whatever was passed to the `style`
+   * option at construction or to the `setStyle` method.
+   * @return {import("../style/Style.js").StyleLike|import("../style/flat.js").FlatStyleLike|null|undefined} Layer style.
+   * @api
+   */
+  getStyle() {
+    return this.style_;
+  }
+  /**
+   * Get the style function.
+   * @return {import("../style/Style.js").StyleFunction|undefined} Layer style function.
+   * @api
+   */
+  getStyleFunction() {
+    return this.styleFunction_;
+  }
+  /**
+   * @return {boolean} Whether the rendered layer should be updated while
+   *     animating.
+   */
+  getUpdateWhileAnimating() {
+    return this.updateWhileAnimating_;
+  }
+  /**
+   * @return {boolean} Whether the rendered layer should be updated while
+   *     interacting.
+   */
+  getUpdateWhileInteracting() {
+    return this.updateWhileInteracting_;
+  }
+  /**
+   * Render declutter items for this layer
+   * @param {import("../Map.js").FrameState} frameState Frame state.
+   * @param {import("../layer/Layer.js").State} layerState Layer state.
+   * @override
+   */
+  renderDeclutter(e, r) {
+    const d = this.getDeclutter();
+    d in e.declutter || (e.declutter[d] = new f(9)), this.getRenderer().renderDeclutter(e, r);
+  }
+  /**
+   * @param {import("../render.js").OrderFunction|null|undefined} renderOrder
+   *     Render order.
+   */
+  setRenderOrder(e) {
+    this.set(a.RENDER_ORDER, e);
+  }
+  /**
+   * Set the style for features.  This can be a single style object, an array
+   * of styles, or a function that takes a feature and resolution and returns
+   * an array of styles. If set to `null`, the layer has no style (a `null` style),
+   * so only features that have their own styles will be rendered in the layer. Call
+   * `setStyle()` without arguments to reset to the default style. See
+   * [the ol/style/Style module]{@link module:ol/style/Style~Style} for information on the default style.
+   *
+   * If your layer has a static style, you can use [flat style]{@link module:ol/style/flat~FlatStyle} object
+   * literals instead of using the `Style` and symbolizer constructors (`Fill`, `Stroke`, etc.):
+   * ```js
+   * vectorLayer.setStyle({
+   *   "fill-color": "yellow",
+   *   "stroke-color": "black",
+   *   "stroke-width": 4
+   * })
+   * ```
+   *
+   * @param {import("../style/Style.js").StyleLike|import("../style/flat.js").FlatStyleLike|null} [style] Layer style.
+   * @api
+   */
+  setStyle(e) {
+    this.style_ = e === void 0 ? c : e;
+    const r = _(e);
+    this.styleFunction_ = e === null ? void 0 : g(r), this.changed();
+  }
+  /**
+   * @param {boolean|string|number} declutter Declutter images and text.
+   * @api
+   */
+  setDeclutter(e) {
+    this.declutter_ = e ? String(e) : void 0, this.changed();
+  }
+}
+function _(t) {
+  if (t === void 0)
+    return c;
+  if (!t)
+    return null;
+  if (typeof t == "function" || t instanceof l)
+    return t;
+  if (!Array.isArray(t))
+    return s([t]);
+  if (t.length === 0)
+    return [];
+  const e = t.length, r = t[0];
+  if (r instanceof l) {
+    const i = new Array(e);
+    for (let n = 0; n < e; ++n) {
+      const u = t[n];
+      if (!(u instanceof l))
+        throw new Error("Expected a list of style instances");
+      i[n] = u;
+    }
+    return i;
+  }
+  if ("style" in r) {
+    const i = new Array(e);
+    for (let n = 0; n < e; ++n) {
+      const u = t[n];
+      if (!("style" in u))
+        throw new Error("Expected a list of rules with a style property");
+      i[n] = u;
+    }
+    return h(i);
+  }
+  return s(
+    /** @type {Array<import("../style/flat.js").FlatStyle>} */
+    t
+  );
+}
+const D = y;
+export {
+  D as default
+};

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

@@ -0,0 +1,226 @@
+import L from "../Collection.mjs";
+import m from "../CollectionEventType.mjs";
+import f from "../ObjectEventType.mjs";
+import { assert as p } from "../asserts.mjs";
+import g from "../events/Event.mjs";
+import A from "../events/EventType.mjs";
+import { unlistenByKey as y, listen as o } from "../events.mjs";
+import { getIntersection as R } from "../extent.mjs";
+import { clear as _ } from "../obj.mjs";
+import { getUid as E } from "../util.mjs";
+import x from "./Base.mjs";
+const i = {
+  /**
+   * Triggered when a layer is added
+   * @event GroupEvent#addlayer
+   * @api
+   */
+  ADDLAYER: "addlayer",
+  /**
+   * Triggered when a layer is removed
+   * @event GroupEvent#removelayer
+   * @api
+   */
+  REMOVELAYER: "removelayer"
+};
+class h extends g {
+  /**
+   * @param {GroupEventType} type The event type.
+   * @param {BaseLayer} layer The layer.
+   */
+  constructor(e, t) {
+    super(e), this.layer = t;
+  }
+}
+const d = {
+  LAYERS: "layers"
+};
+class c extends x {
+  /**
+   * @param {Options} [options] Layer options.
+   */
+  constructor(e) {
+    e = e || {};
+    const t = (
+      /** @type {Options} */
+      Object.assign({}, e)
+    );
+    delete t.layers;
+    let s = e.layers;
+    super(t), this.on, this.once, this.un, this.layersListenerKeys_ = [], this.listenerKeys_ = {}, this.addChangeListener(d.LAYERS, this.handleLayersChanged_), s ? Array.isArray(s) ? s = new L(s.slice(), { unique: !0 }) : p(
+      typeof /** @type {?} */
+      s.getArray == "function",
+      "Expected `layers` to be an array or a `Collection`"
+    ) : s = new L(void 0, { unique: !0 }), this.setLayers(s);
+  }
+  /**
+   * @private
+   */
+  handleLayerChange_() {
+    this.changed();
+  }
+  /**
+   * @private
+   */
+  handleLayersChanged_() {
+    this.layersListenerKeys_.forEach(y), this.layersListenerKeys_.length = 0;
+    const e = this.getLayers();
+    this.layersListenerKeys_.push(
+      o(e, m.ADD, this.handleLayersAdd_, this),
+      o(
+        e,
+        m.REMOVE,
+        this.handleLayersRemove_,
+        this
+      )
+    );
+    for (const s in this.listenerKeys_)
+      this.listenerKeys_[s].forEach(y);
+    _(this.listenerKeys_);
+    const t = e.getArray();
+    for (let s = 0, n = t.length; s < n; s++) {
+      const a = t[s];
+      this.registerLayerListeners_(a), this.dispatchEvent(new h(i.ADDLAYER, a));
+    }
+    this.changed();
+  }
+  /**
+   * @param {BaseLayer} layer The layer.
+   */
+  registerLayerListeners_(e) {
+    const t = [
+      o(
+        e,
+        f.PROPERTYCHANGE,
+        this.handleLayerChange_,
+        this
+      ),
+      o(e, A.CHANGE, this.handleLayerChange_, this)
+    ];
+    e instanceof c && t.push(
+      o(e, i.ADDLAYER, this.handleLayerGroupAdd_, this),
+      o(
+        e,
+        i.REMOVELAYER,
+        this.handleLayerGroupRemove_,
+        this
+      )
+    ), this.listenerKeys_[E(e)] = t;
+  }
+  /**
+   * @param {GroupEvent} event The layer group event.
+   */
+  handleLayerGroupAdd_(e) {
+    this.dispatchEvent(new h(i.ADDLAYER, e.layer));
+  }
+  /**
+   * @param {GroupEvent} event The layer group event.
+   */
+  handleLayerGroupRemove_(e) {
+    this.dispatchEvent(new h(i.REMOVELAYER, e.layer));
+  }
+  /**
+   * @param {import("../Collection.js").CollectionEvent<import("./Base.js").default>} collectionEvent CollectionEvent.
+   * @private
+   */
+  handleLayersAdd_(e) {
+    const t = e.element;
+    this.registerLayerListeners_(t), this.dispatchEvent(new h(i.ADDLAYER, t)), this.changed();
+  }
+  /**
+   * @param {import("../Collection.js").CollectionEvent<import("./Base.js").default>} collectionEvent CollectionEvent.
+   * @private
+   */
+  handleLayersRemove_(e) {
+    const t = e.element, s = E(t);
+    this.listenerKeys_[s].forEach(y), delete this.listenerKeys_[s], this.dispatchEvent(new h(i.REMOVELAYER, t)), this.changed();
+  }
+  /**
+   * Returns the {@link module:ol/Collection~Collection collection} of {@link module:ol/layer/Layer~Layer layers}
+   * in this group.
+   * @return {!Collection<import("./Base.js").default>} Collection of
+   *   {@link module:ol/layer/Base~BaseLayer layers} that are part of this group.
+   * @observable
+   * @api
+   */
+  getLayers() {
+    return (
+      /** @type {!Collection<import("./Base.js").default>} */
+      this.get(d.LAYERS)
+    );
+  }
+  /**
+   * Set the {@link module:ol/Collection~Collection collection} of {@link module:ol/layer/Layer~Layer layers}
+   * in this group.
+   * @param {!Collection<import("./Base.js").default>} layers Collection of
+   *   {@link module:ol/layer/Base~BaseLayer layers} that are part of this group.
+   * @observable
+   * @api
+   */
+  setLayers(e) {
+    const t = this.getLayers();
+    if (t) {
+      const s = t.getArray();
+      for (let n = 0, a = s.length; n < a; ++n)
+        this.dispatchEvent(
+          new h(i.REMOVELAYER, s[n])
+        );
+    }
+    this.set(d.LAYERS, e);
+  }
+  /**
+   * @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 !== void 0 ? e : [], this.getLayers().forEach(function(t) {
+      t.getLayersArray(e);
+    }), e;
+  }
+  /**
+   * Get the layer states list and use this groups z-index as the default
+   * for all layers in this and nested groups, if it is unset at this point.
+   * If dest is not provided and this group's z-index is undefined
+   * 0 is used a the default z-index.
+   * @param {Array<import("./Layer.js").State>} [dest] Optional list
+   * of layer states (to be modified in place).
+   * @return {Array<import("./Layer.js").State>} List of layer states.
+   * @override
+   */
+  getLayerStatesArray(e) {
+    const t = e !== void 0 ? e : [], s = t.length;
+    this.getLayers().forEach(function(l) {
+      l.getLayerStatesArray(t);
+    });
+    const n = this.getLayerState();
+    let a = n.zIndex;
+    !e && n.zIndex === void 0 && (a = 0);
+    for (let l = s, u = t.length; l < u; l++) {
+      const r = t[l];
+      r.opacity *= n.opacity, r.visible = r.visible && n.visible, r.maxResolution = Math.min(
+        r.maxResolution,
+        n.maxResolution
+      ), r.minResolution = Math.max(
+        r.minResolution,
+        n.minResolution
+      ), r.minZoom = Math.max(r.minZoom, n.minZoom), r.maxZoom = Math.min(r.maxZoom, n.maxZoom), n.extent !== void 0 && (r.extent !== void 0 ? r.extent = R(
+        r.extent,
+        n.extent
+      ) : r.extent = n.extent), r.zIndex === void 0 && (r.zIndex = a);
+    }
+    return t;
+  }
+  /**
+   * @return {import("../source/Source.js").State} Source state.
+   * @override
+   */
+  getSourceState() {
+    return "ready";
+  }
+}
+const I = c;
+export {
+  h as GroupEvent,
+  I as default
+};