gisviewer-vue3-arcgis 1.0.281 → 1.0.283

package/es/node_modules/.pnpm/ol@10.7.0/node_modules/ol/interaction/MouseWheelZoom.mjs

@@ -0,0 +1,109 @@
+import l from "../events/EventType.mjs";
+import { always as d, all as r, focusWithTabindex as _ } from "../events/condition.mjs";
+import { clamp as u } from "../math.mjs";
+import c, { zoomByDelta as m } from "./Interaction.mjs";
+const f = 40, A = 300;
+class T extends c {
+  /**
+   * @param {Options} [options] Options.
+   */
+  constructor(t) {
+    t = t || {}, super(
+      /** @type {import("./Interaction.js").InteractionOptions} */
+      t
+    ), this.totalDelta_ = 0, this.lastDelta_ = 0, this.maxDelta_ = t.maxDelta !== void 0 ? t.maxDelta : 1, this.duration_ = t.duration !== void 0 ? t.duration : 250, this.timeout_ = t.timeout !== void 0 ? t.timeout : 80, this.useAnchor_ = t.useAnchor !== void 0 ? t.useAnchor : !0, this.constrainResolution_ = t.constrainResolution !== void 0 ? t.constrainResolution : !1;
+    const e = t.condition ? t.condition : d;
+    this.condition_ = t.onFocusOnly ? r(_, e) : e, this.lastAnchor_ = null, this.startTime_ = void 0, this.timeoutId_, this.mode_ = void 0, this.trackpadEventGap_ = 400, this.trackpadTimeoutId_, this.deltaPerZoom_ = 300;
+  }
+  /**
+   * @private
+   */
+  endInteraction_() {
+    this.trackpadTimeoutId_ = void 0;
+    const t = this.getMap();
+    if (!t)
+      return;
+    t.getView().endInteraction(
+      void 0,
+      this.lastDelta_ ? this.lastDelta_ > 0 ? 1 : -1 : 0,
+      this.lastAnchor_ ? t.getCoordinateFromPixel(this.lastAnchor_) : null
+    );
+  }
+  /**
+   * Handles the {@link module:ol/MapBrowserEvent~MapBrowserEvent map browser event} (if it was a mousewheel-event) and eventually
+   * zooms the map.
+   * @param {import("../MapBrowserEvent.js").default} mapBrowserEvent Map browser event.
+   * @return {boolean} `false` to stop event propagation.
+   * @override
+   */
+  handleEvent(t) {
+    if (!this.condition_(t) || t.type !== l.WHEEL)
+      return !0;
+    const i = t.map, o = (
+      /** @type {WheelEvent} */
+      t.originalEvent
+    );
+    o.preventDefault(), this.useAnchor_ && (this.lastAnchor_ = t.pixel);
+    let n = o.deltaY;
+    switch (o.deltaMode) {
+      case WheelEvent.DOM_DELTA_LINE:
+        n *= f;
+        break;
+      case WheelEvent.DOM_DELTA_PAGE:
+        n *= A;
+        break;
+    }
+    if (n === 0)
+      return !1;
+    this.lastDelta_ = n;
+    const s = Date.now();
+    this.startTime_ === void 0 && (this.startTime_ = s), (!this.mode_ || s - this.startTime_ > this.trackpadEventGap_) && (this.mode_ = Math.abs(n) < 4 ? "trackpad" : "wheel");
+    const a = i.getView();
+    if (this.mode_ === "trackpad" && !(a.getConstrainResolution() || this.constrainResolution_))
+      return this.trackpadTimeoutId_ ? clearTimeout(this.trackpadTimeoutId_) : (a.getAnimating() && a.cancelAnimations(), a.beginInteraction()), this.trackpadTimeoutId_ = setTimeout(
+        this.endInteraction_.bind(this),
+        this.timeout_
+      ), a.adjustZoom(
+        -n / this.deltaPerZoom_,
+        this.lastAnchor_ ? i.getCoordinateFromPixel(this.lastAnchor_) : null
+      ), this.startTime_ = s, !1;
+    this.totalDelta_ += n;
+    const h = Math.max(this.timeout_ - (s - this.startTime_), 0);
+    return clearTimeout(this.timeoutId_), this.timeoutId_ = setTimeout(
+      this.handleWheelZoom_.bind(this, i),
+      h
+    ), !1;
+  }
+  /**
+   * @private
+   * @param {import("../Map.js").default} map Map.
+   */
+  handleWheelZoom_(t) {
+    const e = t.getView();
+    e.getAnimating() && e.cancelAnimations();
+    let i = -u(
+      this.totalDelta_,
+      -this.maxDelta_ * this.deltaPerZoom_,
+      this.maxDelta_ * this.deltaPerZoom_
+    ) / this.deltaPerZoom_;
+    (e.getConstrainResolution() || this.constrainResolution_) && (i = i ? i > 0 ? 1 : -1 : 0), m(
+      e,
+      i,
+      this.lastAnchor_ ? t.getCoordinateFromPixel(this.lastAnchor_) : null,
+      this.duration_
+    ), this.mode_ = void 0, this.totalDelta_ = 0, this.lastAnchor_ = null, this.startTime_ = void 0, this.timeoutId_ = void 0;
+  }
+  /**
+   * Enable or disable using the mouse's location as an anchor when zooming
+   * @param {boolean} useAnchor true to zoom to the mouse's location, false
+   * to zoom to the center of the map
+   * @api
+   */
+  setMouseAnchor(t) {
+    this.useAnchor_ = t, t || (this.lastAnchor_ = null);
+  }
+}
+const L = T;
+export {
+  L as default
+};

package/es/node_modules/.pnpm/ol@10.7.0/node_modules/ol/interaction/PinchRotate.mjs

@@ -0,0 +1,63 @@
+import { FALSE as h } from "../functions.mjs";
+import { disable as l } from "../rotationconstraint.mjs";
+import c, { centroid as d } from "./Pointer.mjs";
+class g extends c {
+  /**
+   * @param {Options} [options] Options.
+   */
+  constructor(t) {
+    t = t || {};
+    const e = (
+      /** @type {import("./Pointer.js").Options} */
+      t
+    );
+    e.stopDown || (e.stopDown = h), super(e), this.anchor_ = null, this.lastAngle_ = void 0, this.rotating_ = !1, this.rotationDelta_ = 0, this.threshold_ = t.threshold !== void 0 ? t.threshold : 0.3, this.duration_ = t.duration !== void 0 ? t.duration : 250;
+  }
+  /**
+   * Handle pointer drag events.
+   * @param {import("../MapBrowserEvent.js").default} mapBrowserEvent Event.
+   * @override
+   */
+  handleDragEvent(t) {
+    let e = 0;
+    const i = this.targetPointers[0], a = this.targetPointers[1], r = Math.atan2(
+      a.clientY - i.clientY,
+      a.clientX - i.clientX
+    );
+    if (this.lastAngle_ !== void 0) {
+      const o = r - this.lastAngle_;
+      this.rotationDelta_ += o, !this.rotating_ && Math.abs(this.rotationDelta_) > this.threshold_ && (this.rotating_ = !0), e = o;
+    }
+    this.lastAngle_ = r;
+    const n = t.map, s = n.getView();
+    s.getConstraints().rotation !== l && (this.anchor_ = n.getCoordinateFromPixelInternal(
+      n.getEventPixel(d(this.targetPointers))
+    ), this.rotating_ && (n.render(), s.adjustRotationInternal(e, this.anchor_)));
+  }
+  /**
+   * Handle pointer up events.
+   * @param {import("../MapBrowserEvent.js").default} mapBrowserEvent Event.
+   * @return {boolean} If the event was consumed.
+   * @override
+   */
+  handleUpEvent(t) {
+    return this.targetPointers.length < 2 ? (t.map.getView().endInteraction(this.duration_), !1) : !0;
+  }
+  /**
+   * Handle pointer down events.
+   * @param {import("../MapBrowserEvent.js").default} mapBrowserEvent Event.
+   * @return {boolean} If the event was consumed.
+   * @override
+   */
+  handleDownEvent(t) {
+    if (this.targetPointers.length >= 2) {
+      const e = t.map;
+      return this.anchor_ = null, this.lastAngle_ = void 0, this.rotating_ = !1, this.rotationDelta_ = 0, this.handlingDownUpSequence || e.getView().beginInteraction(), !0;
+    }
+    return !1;
+  }
+}
+const p = g;
+export {
+  p as default
+};

package/es/node_modules/.pnpm/ol@10.7.0/node_modules/ol/interaction/PinchZoom.mjs

@@ -0,0 +1,59 @@
+import { FALSE as l } from "../functions.mjs";
+import h, { centroid as d } from "./Pointer.mjs";
+class u extends h {
+  /**
+   * @param {Options} [options] Options.
+   */
+  constructor(t) {
+    t = t || {};
+    const e = (
+      /** @type {import("./Pointer.js").Options} */
+      t
+    );
+    e.stopDown || (e.stopDown = l), super(e), this.anchor_ = null, this.duration_ = t.duration !== void 0 ? t.duration : 400, this.lastDistance_ = void 0, this.lastScaleDelta_ = 1;
+  }
+  /**
+   * Handle pointer drag events.
+   * @param {import("../MapBrowserEvent.js").default} mapBrowserEvent Event.
+   * @override
+   */
+  handleDragEvent(t) {
+    let e = 1;
+    const n = this.targetPointers[0], i = this.targetPointers[1], a = n.clientX - i.clientX, r = n.clientY - i.clientY, o = Math.sqrt(a * a + r * r);
+    this.lastDistance_ !== void 0 && (e = this.lastDistance_ / o), this.lastDistance_ = o;
+    const s = t.map, c = s.getView();
+    e != 1 && (this.lastScaleDelta_ = e), this.anchor_ = s.getCoordinateFromPixelInternal(
+      s.getEventPixel(d(this.targetPointers))
+    ), s.render(), c.adjustResolutionInternal(e, this.anchor_);
+  }
+  /**
+   * Handle pointer up events.
+   * @param {import("../MapBrowserEvent.js").default} mapBrowserEvent Event.
+   * @return {boolean} If the event was consumed.
+   * @override
+   */
+  handleUpEvent(t) {
+    if (this.targetPointers.length < 2) {
+      const n = t.map.getView(), i = this.lastScaleDelta_ > 1 ? 1 : -1;
+      return n.endInteraction(this.duration_, i), !1;
+    }
+    return !0;
+  }
+  /**
+   * Handle pointer down events.
+   * @param {import("../MapBrowserEvent.js").default} mapBrowserEvent Event.
+   * @return {boolean} If the event was consumed.
+   * @override
+   */
+  handleDownEvent(t) {
+    if (this.targetPointers.length >= 2) {
+      const e = t.map;
+      return this.anchor_ = null, this.lastDistance_ = void 0, this.lastScaleDelta_ = 1, this.handlingDownUpSequence || e.getView().beginInteraction(), !0;
+    }
+    return !1;
+  }
+}
+const _ = u;
+export {
+  _ as default
+};

package/es/node_modules/.pnpm/ol@10.7.0/node_modules/ol/interaction/Pointer.mjs

@@ -0,0 +1,109 @@
+import h from "../MapBrowserEventType.mjs";
+import a from "./Interaction.mjs";
+class r extends a {
+  /**
+   * @param {Options} [options] Options.
+   */
+  constructor(e) {
+    e = e || {}, super(
+      /** @type {import("./Interaction.js").InteractionOptions} */
+      e
+    ), e.handleDownEvent && (this.handleDownEvent = e.handleDownEvent), e.handleDragEvent && (this.handleDragEvent = e.handleDragEvent), e.handleMoveEvent && (this.handleMoveEvent = e.handleMoveEvent), e.handleUpEvent && (this.handleUpEvent = e.handleUpEvent), e.stopDown && (this.stopDown = e.stopDown), this.handlingDownUpSequence = !1, this.targetPointers = [];
+  }
+  /**
+   * Returns the current number of pointers involved in the interaction,
+   * e.g. `2` when two fingers are used.
+   * @return {number} The number of pointers.
+   * @api
+   */
+  getPointerCount() {
+    return this.targetPointers.length;
+  }
+  /**
+   * Handle pointer down events.
+   * @param {import("../MapBrowserEvent.js").default} mapBrowserEvent Event.
+   * @return {boolean} If the event was consumed.
+   * @protected
+   */
+  handleDownEvent(e) {
+    return !1;
+  }
+  /**
+   * Handle pointer drag events.
+   * @param {import("../MapBrowserEvent.js").default} mapBrowserEvent Event.
+   * @protected
+   */
+  handleDragEvent(e) {
+  }
+  /**
+   * Handles the {@link module:ol/MapBrowserEvent~MapBrowserEvent map browser event} and may call into
+   * other functions, if event sequences like e.g. 'drag' or 'down-up' etc. are
+   * detected.
+   * @param {import("../MapBrowserEvent.js").default} mapBrowserEvent Map browser event.
+   * @return {boolean} `false` to stop event propagation.
+   * @api
+   * @override
+   */
+  handleEvent(e) {
+    if (!e.originalEvent)
+      return !0;
+    let n = !1;
+    if (this.updateTrackedPointers_(e), this.handlingDownUpSequence) {
+      if (e.type == h.POINTERDRAG)
+        this.handleDragEvent(e), e.originalEvent.preventDefault();
+      else if (e.type == h.POINTERUP) {
+        const t = this.handleUpEvent(e);
+        this.handlingDownUpSequence = t && this.targetPointers.length > 0;
+      }
+    } else if (e.type == h.POINTERDOWN) {
+      const t = this.handleDownEvent(e);
+      this.handlingDownUpSequence = t, n = this.stopDown(t);
+    } else
+      e.type == h.POINTERMOVE && this.handleMoveEvent(e);
+    return !n;
+  }
+  /**
+   * Handle pointer move events.
+   * @param {import("../MapBrowserEvent.js").default} mapBrowserEvent Event.
+   * @protected
+   */
+  handleMoveEvent(e) {
+  }
+  /**
+   * Handle pointer up events.
+   * @param {import("../MapBrowserEvent.js").default} mapBrowserEvent Event.
+   * @return {boolean} If the event was consumed.
+   * @protected
+   */
+  handleUpEvent(e) {
+    return !1;
+  }
+  /**
+   * This function is used to determine if "down" events should be propagated
+   * to other interactions or should be stopped.
+   * @param {boolean} handled Was the event handled by the interaction?
+   * @return {boolean} Should the `down` event be stopped?
+   */
+  stopDown(e) {
+    return e;
+  }
+  /**
+   * @param {import("../MapBrowserEvent.js").default} mapBrowserEvent Event.
+   * @private
+   */
+  updateTrackedPointers_(e) {
+    e.activePointers && (this.targetPointers = e.activePointers);
+  }
+}
+function c(l) {
+  const e = l.length;
+  let n = 0, t = 0;
+  for (let i = 0; i < e; i++)
+    n += l[i].clientX, t += l[i].clientY;
+  return { clientX: n / e, clientY: t / e };
+}
+const v = r;
+export {
+  c as centroid,
+  v as default
+};

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

@@ -0,0 +1,6 @@
+const t = {
+  ACTIVE: "active"
+};
+export {
+  t as default
+};

package/es/node_modules/.pnpm/ol@10.7.0/node_modules/ol/interaction/defaults.mjs

@@ -0,0 +1,47 @@
+import t from "../Collection.mjs";
+import a from "../Kinetic.mjs";
+import m from "./DoubleClickZoom.mjs";
+import n from "./DragPan.mjs";
+import u from "./DragRotate.mjs";
+import i from "./DragZoom.mjs";
+import d from "./KeyboardPan.mjs";
+import f from "./KeyboardZoom.mjs";
+import c from "./MouseWheelZoom.mjs";
+import h from "./PinchRotate.mjs";
+import l from "./PinchZoom.mjs";
+function M(e) {
+  e = e || {};
+  const o = new t(), r = new a(-5e-3, 0.05, 100);
+  return (e.altShiftDragRotate !== void 0 ? e.altShiftDragRotate : !0) && o.push(new u()), (e.doubleClickZoom !== void 0 ? e.doubleClickZoom : !0) && o.push(
+    new m({
+      delta: e.zoomDelta,
+      duration: e.zoomDuration
+    })
+  ), (e.dragPan !== void 0 ? e.dragPan : !0) && o.push(
+    new n({
+      onFocusOnly: e.onFocusOnly,
+      kinetic: r
+    })
+  ), (e.pinchRotate !== void 0 ? e.pinchRotate : !0) && o.push(new h()), (e.pinchZoom !== void 0 ? e.pinchZoom : !0) && o.push(
+    new l({
+      duration: e.zoomDuration
+    })
+  ), (e.keyboard !== void 0 ? e.keyboard : !0) && (o.push(new d()), o.push(
+    new f({
+      delta: e.zoomDelta,
+      duration: e.zoomDuration
+    })
+  )), (e.mouseWheelZoom !== void 0 ? e.mouseWheelZoom : !0) && o.push(
+    new c({
+      onFocusOnly: e.onFocusOnly,
+      duration: e.zoomDuration
+    })
+  ), (e.shiftDragZoom !== void 0 ? e.shiftDragZoom : !0) && o.push(
+    new i({
+      duration: e.zoomDuration
+    })
+  ), o;
+}
+export {
+  M as defaults
+};

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

@@ -0,0 +1,270 @@
+import a from "../Object.mjs";
+import { assert as n } from "../asserts.mjs";
+import { clamp as o } from "../math.mjs";
+import { abstract as i } from "../util.mjs";
+import s from "./Property.mjs";
+class u extends a {
+  /**
+   * @param {Options} options Layer options.
+   */
+  constructor(e) {
+    super(), this.on, this.once, this.un, this.background_ = e.background;
+    const t = Object.assign({}, e);
+    typeof e.properties == "object" && (delete t.properties, Object.assign(t, e.properties)), t[s.OPACITY] = e.opacity !== void 0 ? e.opacity : 1, n(
+      typeof t[s.OPACITY] == "number",
+      "Layer opacity must be a number"
+    ), t[s.VISIBLE] = e.visible !== void 0 ? e.visible : !0, t[s.Z_INDEX] = e.zIndex, t[s.MAX_RESOLUTION] = e.maxResolution !== void 0 ? e.maxResolution : 1 / 0, t[s.MIN_RESOLUTION] = e.minResolution !== void 0 ? e.minResolution : 0, t[s.MIN_ZOOM] = e.minZoom !== void 0 ? e.minZoom : -1 / 0, t[s.MAX_ZOOM] = e.maxZoom !== void 0 ? e.maxZoom : 1 / 0, this.className_ = t.className !== void 0 ? t.className : "ol-layer", delete t.className, this.setProperties(t), this.state_ = null;
+  }
+  /**
+   * Get the background for this layer.
+   * @return {BackgroundColor|false} Layer background.
+   */
+  getBackground() {
+    return this.background_;
+  }
+  /**
+   * @return {string} CSS class name.
+   */
+  getClassName() {
+    return this.className_;
+  }
+  /**
+   * This method is not meant to be called by layers or layer renderers because the state
+   * is incorrect if the layer is included in a layer group.
+   *
+   * @param {boolean} [managed] Layer is managed.
+   * @return {import("./Layer.js").State} Layer state.
+   */
+  getLayerState(e) {
+    const t = this.state_ || /** @type {?} */
+    {
+      layer: this,
+      managed: e === void 0 ? !0 : e
+    }, r = this.getZIndex();
+    return t.opacity = o(Math.round(this.getOpacity() * 100) / 100, 0, 1), t.visible = this.getVisible(), t.extent = this.getExtent(), t.zIndex = r === void 0 && !t.managed ? 1 / 0 : r, t.maxResolution = this.getMaxResolution(), t.minResolution = Math.max(this.getMinResolution(), 0), t.minZoom = this.getMinZoom(), t.maxZoom = this.getMaxZoom(), this.state_ = t, t;
+  }
+  /**
+   * @abstract
+   * @param {Array<import("./Layer.js").default>} [array] Array of layers (to be
+   *     modified in place).
+   * @return {Array<import("./Layer.js").default>} Array of layers.
+   */
+  getLayersArray(e) {
+    return i();
+  }
+  /**
+   * @abstract
+   * @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.
+   */
+  getLayerStatesArray(e) {
+    return i();
+  }
+  /**
+   * Return the {@link module:ol/extent~Extent extent} of the layer or `undefined` if it
+   * will be visible regardless of extent.
+   * @return {import("../extent.js").Extent|undefined} The layer extent.
+   * @observable
+   * @api
+   */
+  getExtent() {
+    return (
+      /** @type {import("../extent.js").Extent|undefined} */
+      this.get(s.EXTENT)
+    );
+  }
+  /**
+   * Return the maximum resolution of the layer. Returns Infinity if
+   * the layer has no maximum resolution set.
+   * @return {number} The maximum resolution of the layer.
+   * @observable
+   * @api
+   */
+  getMaxResolution() {
+    return (
+      /** @type {number} */
+      this.get(s.MAX_RESOLUTION)
+    );
+  }
+  /**
+   * Return the minimum resolution of the layer. Returns 0 if
+   * the layer has no minimum resolution set.
+   * @return {number} The minimum resolution of the layer.
+   * @observable
+   * @api
+   */
+  getMinResolution() {
+    return (
+      /** @type {number} */
+      this.get(s.MIN_RESOLUTION)
+    );
+  }
+  /**
+   * Return the minimum zoom level of the layer. Returns -Infinity if
+   * the layer has no minimum zoom set.
+   * @return {number} The minimum zoom level of the layer.
+   * @observable
+   * @api
+   */
+  getMinZoom() {
+    return (
+      /** @type {number} */
+      this.get(s.MIN_ZOOM)
+    );
+  }
+  /**
+   * Return the maximum zoom level of the layer. Returns Infinity if
+   * the layer has no maximum zoom set.
+   * @return {number} The maximum zoom level of the layer.
+   * @observable
+   * @api
+   */
+  getMaxZoom() {
+    return (
+      /** @type {number} */
+      this.get(s.MAX_ZOOM)
+    );
+  }
+  /**
+   * Return the opacity of the layer (between 0 and 1).
+   * @return {number} The opacity of the layer.
+   * @observable
+   * @api
+   */
+  getOpacity() {
+    return (
+      /** @type {number} */
+      this.get(s.OPACITY)
+    );
+  }
+  /**
+   * @abstract
+   * @return {import("../source/Source.js").State} Source state.
+   */
+  getSourceState() {
+    return i();
+  }
+  /**
+   * Return the value of this layer's `visible` property. To find out whether the layer
+   * is visible on a map, use `isVisible()` instead.
+   * @return {boolean} The value of the `visible` property of the layer.
+   * @observable
+   * @api
+   */
+  getVisible() {
+    return (
+      /** @type {boolean} */
+      this.get(s.VISIBLE)
+    );
+  }
+  /**
+   * Return the Z-index of the layer, which is used to order layers before
+   * rendering. Returns undefined if the layer is unmanaged.
+   * @return {number|undefined} The Z-index of the layer.
+   * @observable
+   * @api
+   */
+  getZIndex() {
+    return (
+      /** @type {number|undefined} */
+      this.get(s.Z_INDEX)
+    );
+  }
+  /**
+   * Sets the background color.
+   * @param {BackgroundColor} [background] Background color.
+   */
+  setBackground(e) {
+    this.background_ = e, this.changed();
+  }
+  /**
+   * Set the extent at which the layer is visible.  If `undefined`, the layer
+   * will be visible at all extents.
+   * @param {import("../extent.js").Extent|undefined} extent The extent of the layer.
+   * @observable
+   * @api
+   */
+  setExtent(e) {
+    this.set(s.EXTENT, e);
+  }
+  /**
+   * Set the maximum resolution at which the layer is visible.
+   * @param {number} maxResolution The maximum resolution of the layer.
+   * @observable
+   * @api
+   */
+  setMaxResolution(e) {
+    this.set(s.MAX_RESOLUTION, e);
+  }
+  /**
+   * Set the minimum resolution at which the layer is visible.
+   * @param {number} minResolution The minimum resolution of the layer.
+   * @observable
+   * @api
+   */
+  setMinResolution(e) {
+    this.set(s.MIN_RESOLUTION, e);
+  }
+  /**
+   * Set the maximum zoom (exclusive) at which the layer is visible.
+   * Note that the zoom levels for layer visibility are based on the
+   * view zoom level, which may be different from a tile source zoom level.
+   * @param {number} maxZoom The maximum zoom of the layer.
+   * @observable
+   * @api
+   */
+  setMaxZoom(e) {
+    this.set(s.MAX_ZOOM, e);
+  }
+  /**
+   * Set the minimum zoom (inclusive) at which the layer is visible.
+   * Note that the zoom levels for layer visibility are based on the
+   * view zoom level, which may be different from a tile source zoom level.
+   * @param {number} minZoom The minimum zoom of the layer.
+   * @observable
+   * @api
+   */
+  setMinZoom(e) {
+    this.set(s.MIN_ZOOM, e);
+  }
+  /**
+   * Set the opacity of the layer, allowed values range from 0 to 1.
+   * @param {number} opacity The opacity of the layer.
+   * @observable
+   * @api
+   */
+  setOpacity(e) {
+    n(typeof e == "number", "Layer opacity must be a number"), this.set(s.OPACITY, e);
+  }
+  /**
+   * Set the visibility of the layer (`true` or `false`).
+   * @param {boolean} visible The visibility of the layer.
+   * @observable
+   * @api
+   */
+  setVisible(e) {
+    this.set(s.VISIBLE, e);
+  }
+  /**
+   * Set Z-index of the layer, which is used to order layers before rendering.
+   * The default Z-index is 0.
+   * @param {number} zindex The z-index of the layer.
+   * @observable
+   * @api
+   */
+  setZIndex(e) {
+    this.set(s.Z_INDEX, e);
+  }
+  /**
+   * Clean up.
+   * @override
+   */
+  disposeInternal() {
+    this.state_ && (this.state_.layer = null, this.state_ = null), super.disposeInternal();
+  }
+}
+const c = u;
+export {
+  c as default
+};