@vcmap/viewshed 2.0.1

package/dist/index.js

@@ -0,0 +1,1423 @@
+var ue = Object.defineProperty;
+var fe = (s, e, t) => e in s ? ue(s, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : s[e] = t;
+var Z = (s, e, t) => (fe(s, typeof e != "symbol" ? e + "" : e, t), t);
+import { VcsCameraPrimitive as ve, VcsObject as pe, VcsEvent as L, AbstractInteraction as we, EventType as D, Projection as I, SessionType as me, CesiumMap as B, startEditFeaturesSession as ge, startEditGeometrySession as _e, VectorLayer as Ce, wgs84Projection as Ee, maxZIndex as Ve, markVolatile as ye, Viewpoint as be, TransformationMode as Me, Category as Te, moduleIdSymbol as Oe } from "../../../assets/core.js";
+import { Color as k, Matrix4 as Se, Transforms as Pe, Primitive as q, GeometryInstance as Q, SphereGeometry as Ae, ColorGeometryInstanceAttribute as ee, PerInstanceColorAppearance as te, SphereOutlineGeometry as Ie, Math as O, Cartesian3 as S, ShadowMap as Re, Camera as $e, HeightReference as Ne } from "../../../assets/cesium.js";
+import { shallowRef as H, ref as A, nextTick as xe, inject as ie, reactive as j, watchEffect as De, watch as R, onMounted as Le, onUnmounted as Fe, computed as ke } from "../../../assets/vue.js";
+import { ol$Observable$unByKey as je, Feature as We, ol$geom$Point as Be, ol$style$Style as ze } from "../../../assets/ol.js";
+import { VcsTextField as Ge, VcsSlider as Ue, VcsLabel as oe, VcsFormSection as ne, VcsSelect as re, VcsFormButton as He, VcsFeatureTransforms as Xe, makeEditorCollectionComponentClass as Ke, WindowSlot as Ye, ToolboxType as Je, createListExportAction as Ze, downloadText as qe, createListImportAction as Qe, AbstractConfigEditor as et } from "../../../assets/ui.js";
+import { VContainer as ae, VRow as le, VCol as ce, VDivider as tt, VColorPicker as it } from "../../../assets/vuetify.js";
+const x = [
+  [String, "string"],
+  [Number, "number"],
+  [Boolean, "boolean"],
+  [Function, "function"],
+  [void 0, "undefined"],
+  [Symbol, "symbol"]
+];
+function W(s) {
+  const e = {};
+  if (!s || e.toString(s) !== "[object Object]")
+    return !1;
+  const t = Object.getPrototypeOf(s);
+  if (!t)
+    return !0;
+  const i = e.hasOwnProperty, o = i.call(t, "constructor") && t.constructor;
+  return typeof o == "function" && i.toString.call(o) === i.toString.call(Object);
+}
+function M(s, e) {
+  if (s === null)
+    return "null";
+  if (typeof s > "u")
+    return "undefined";
+  if (e)
+    return typeof s;
+  let t;
+  if (Array.isArray(s))
+    t = `[${s.map((o) => M(o, e)).join(",")}]`;
+  else
+    try {
+      t = JSON.stringify(s);
+    } catch {
+      t = typeof s;
+    }
+  return t = t || typeof s, t.length > 20 ? `${t.substr(0, 20)}...` : t;
+}
+function st(s, e) {
+  return typeof e == "string" || typeof e == "number" || typeof e == "boolean" || typeof e == "symbol" ? s === e ? !1 : `Expected ${M(s)} to equal ${e.toString()}` : null;
+}
+function ot(s, e, t) {
+  if (Array.isArray(e)) {
+    if (e.length !== 1)
+      throw new Error("Array patterns may only have on type");
+    if (Array.isArray(s)) {
+      let i = !1;
+      return s.findIndex((r) => {
+        try {
+          z(r, e[0], t);
+        } catch (a) {
+          i = a.message.replace(/Match failed:\s/, "");
+        }
+        return i;
+      }) > -1 ? `${i} in ${M(s)}` : !1;
+    }
+    return `Expected ${M(s)} to be an Array`;
+  }
+  return null;
+}
+function X(s, e, t) {
+  const i = t ? `${t}.` : "";
+  if (!W(s))
+    return `Expected ${M(s)} to be a plain Object`;
+  let r = !1;
+  const a = Object.keys(e).find((l) => {
+    const n = s[l];
+    if (W(e[l]))
+      r = X(n, e[l], i + l);
+    else
+      try {
+        z(n, e[l]);
+      } catch (u) {
+        r = u.message.replace(/Match failed:\s/, "");
+      }
+    return r;
+  });
+  return a ? `${r} in object.${i}${a}` : !1;
+}
+function nt(s, e) {
+  if (e === Number)
+    return Number.isFinite(s) ? !1 : `expected ${M(s)} to be a number, excluding NaN`;
+  for (let t = x.length; t--; )
+    if (e === x[t][0])
+      return typeof s === x[t][1] ? !1 : `expected ${M(s)} to be a ${x[t][1]}`;
+  return null;
+}
+function K(s) {
+  if (s === null)
+    return "null";
+  const e = x.find((o) => o[0] === s);
+  if (e)
+    return e[1];
+  let t = s.toString();
+  if (s.className)
+    return s.className;
+  const i = t.match(/function (.*)\(/);
+  if (i && i.length > 1)
+    return i[1];
+  if (W(s)) {
+    const o = {};
+    Object.keys(s).forEach((r) => {
+      o[r] = K(s[r]);
+    });
+    try {
+      t = `Object of ${JSON.stringify(o)}`;
+    } catch {
+      t = "Object";
+    }
+  }
+  return t;
+}
+function de(s, e, t) {
+  const i = t ? `${t}.` : "";
+  let o = !1;
+  return Object.keys(s).find((a) => {
+    if (W(e[a])) {
+      const l = s[a];
+      o = de(l, e[a], i + a);
+    } else
+      e[a] || (o = `Found additional key ${i}${a}`);
+    return o = o ? o.replace(/\sin.*/, "") : !1, o;
+  }) ? `${o} in ${M(s)}` : !1;
+}
+function rt(s, e, t) {
+  const i = function(a, l) {
+    if (l == null)
+      return a === l ? !1 : `Expected ${M(a)} to be ${l}`;
+    const n = nt(a, l);
+    if (n !== null)
+      return n;
+    const u = st(a, l);
+    if (u !== null)
+      return u;
+    if (Array.isArray(l))
+      return ot(a, l, t);
+    if (l instanceof Function)
+      return a instanceof l ? !1 : `Expected ${M(a, !0)} to be of Type ${K(l)}`;
+    if (l === Object)
+      return X(a, {});
+    if (typeof l != "object")
+      throw new Error(`Cannot handler pattern ${l}`);
+    const c = X(a, l);
+    return c || (t ? de(a, l) : !1);
+  };
+  let o;
+  return Array.isArray(e) && e.length > 1 ? e.every((a) => i(s, a)) && (o = `Expected ${M(s)} to be a ${e.map((a) => K(a)).join(" or ")}`) : o = i(s, e), o;
+}
+function z(s, e, t) {
+  const i = rt(s, e, t);
+  if (i)
+    throw new Error(`Match failed: ${i}`);
+  return !1;
+}
+function at(s, e, t) {
+  if (s != null) {
+    const i = Object.values(e).find((o) => o == s);
+    if (i != null)
+      return i;
+  }
+  return t;
+}
+const lt = new k(), G = new Se();
+class ct extends ve {
+  constructor(e) {
+    super(e), this.spot = e.spot;
+  }
+  /**
+   * Updates the camera primitive.
+   * @param {unknown} frameState
+   */
+  update(e) {
+    if (this.show)
+      if (this.spot)
+        super.update(e);
+      else {
+        const t = this._planesPrimitives, i = this._outlinePrimitives;
+        t.length === 0 && (Pe.eastNorthUpToFixedFrame(
+          this._camera.positionWC,
+          void 0,
+          G
+        ), t[0] = new q({
+          allowPicking: this.allowPicking,
+          geometryInstances: new Q({
+            geometry: new Ae({
+              radius: 2
+            }),
+            attributes: {
+              color: ee.fromColor(
+                k.fromAlpha(this._color, 0.1, lt)
+              )
+            },
+            modelMatrix: G
+          }),
+          appearance: new te({
+            translucent: !0,
+            flat: !0
+          }),
+          asynchronous: !1
+        }), i[0] = new q({
+          allowPicking: this.allowPicking,
+          geometryInstances: new Q({
+            geometry: new Ie({
+              radius: 2
+            }),
+            attributes: {
+              color: ee.fromColor(this._color)
+            },
+            modelMatrix: G
+          }),
+          appearance: new te({
+            translucent: !1,
+            flat: !0
+          }),
+          asynchronous: !1
+        }));
+        const { length: o } = t;
+        for (let r = 0; r < o; ++r)
+          i[r].update(e), t[r].update(e);
+      }
+  }
+}
+const w = {
+  CONE: "cone",
+  THREESIXTY: "360"
+};
+function dt(s, e) {
+  const t = new $e(s), i = (
+    /** @type {import("@vcmap-cesium/engine").PerspectiveFrustum} */
+    t.frustum
+  );
+  return i.fov = e.fov, i.near = e.near, i.aspectRatio = e.aspectRatio, i.far = e.far, t;
+}
+const E = class E extends pe {
+  static get className() {
+    return "Viewshed";
+  }
+  /**
+   * Returns the default viewshed options.
+   * @returns {{frustum: ShadowFrustumOptions, shadowColor: string, visibleColor: string, orientation: import("@vcmap-cesium/engine").HeadingPitchRollValues, position: import("ol/coordinate").Coordinate}}
+   */
+  static getDefaultOptions() {
+    return {
+      frustum: {
+        fov: O.PI / 3,
+        near: 1,
+        aspectRatio: 1,
+        far: 300
+      },
+      shadowColor: "#3333331A",
+      visibleColor: "#FF990080",
+      orientation: {
+        heading: 0,
+        pitch: 0,
+        roll: 0
+      },
+      position: [0, 0, 0]
+    };
+  }
+  /**
+   * @param {ViewshedOptions} options The options for the viewshed.
+   * @param {import("@vcmap/core").CesiumMap} [cesiumMap] The cesiumMap the viewshed should be applied to. If this parameter is passed, the viewshed is activated and all other viewsheds are deactivated.
+   */
+  constructor(e, t) {
+    var i, o, r, a, l, n;
+    super(e), this._cesiumMap = null, this._shadowCamera = null, this._scene = null, this._frustumOptions = {
+      fov: ((i = e.frustumOptions) == null ? void 0 : i.fov) || E.getDefaultOptions().frustum.fov,
+      far: ((o = e.frustumOptions) == null ? void 0 : o.far) || E.getDefaultOptions().frustum.far,
+      near: ((r = e.frustumOptions) == null ? void 0 : r.near) || E.getDefaultOptions().frustum.near,
+      aspectRatio: ((a = e.frustumOptions) == null ? void 0 : a.aspectRatio) || E.getDefaultOptions().frustum.aspectRatio
+    }, this._headingPitchRollValues = e.orientation || {
+      ...E.getDefaultOptions().orientation
+    }, this._position = e.position || E.getDefaultOptions().position, this._viewshedType = at(e.viewshedType, w), this._colors = {
+      visibleColor: k.fromCssColorString(
+        ((l = e.colorOptions) == null ? void 0 : l.visibleColor) || E.getDefaultOptions().visibleColor
+      ),
+      shadowColor: k.fromCssColorString(
+        ((n = e.colorOptions) == null ? void 0 : n.shadowColor) || E.getDefaultOptions().shadowColor
+      )
+    }, this._heightOffset = e.heightOffset || 0, this._shadowMap = null, this._primitive = null, this._showPrimitive = !!e.showPrimitive, this._shadowMapChangedListener = null, this._positionChanged = new L(), t ? this.activate(t) : this._active = !1;
+  }
+  /**
+   * Sets a new position for the shadow map. If no shadow map was created yet, due to missing position, this method triggers the creation of a shadow map.
+   * @param {import("ol/coordinate").Coordinate} coords The new positions coordinates in degrees
+   */
+  set position(e) {
+    z(e, [Number]), this._position = e, this._shadowCamera && (this._shadowCamera.position = S.fromDegrees(
+      e[0],
+      e[1],
+      e[2] + this._heightOffset
+    ), this._shadowCamera.setView({ orientation: this._headingPitchRollValues }), this._updatePrimitive()), this._positionChanged.raiseEvent(e);
+  }
+  /**
+   * @returns {import("ol/coordinate").Coordinate} The current position of the viewshed source.
+   */
+  get position() {
+    return [...this._position];
+  }
+  /**
+   * Getter for Event that is triggered each time the position is changed.
+   * @returns {import("@vcmap/core").VcsEvent<number[]>} The new position
+   */
+  get positionChanged() {
+    return this._positionChanged;
+  }
+  /**
+   * Sets the height offset of the viewshed.
+   * @param {number} value the offset that is added to the position height.
+   */
+  set heightOffset(e) {
+    this._heightOffset = e, this._shadowCamera && (this._shadowCamera.position = S.fromDegrees(
+      this.position[0],
+      this.position[1],
+      this.position[2] + e
+    ), this._updateShadowMap(), this._updatePrimitive());
+  }
+  /**
+   * Getter for height offset.
+   * @returns {number}
+   */
+  get heightOffset() {
+    return this._heightOffset;
+  }
+  /**
+   * Sets the reach of the viewshed.
+   * @param {number} value The distance in meters.
+   */
+  set distance(e) {
+    this._frustumOptions.far = e > E.MIN_DISTANCE ? e : E.MIN_DISTANCE, this._shadowCamera && (this._shadowCamera.frustum.far = this._frustumOptions.far, this._updateShadowMap(), this._viewshedType === w.CONE && this._updatePrimitive());
+  }
+  /**
+   * Returns the reach of the viewshed.
+   * @returns {number} The distance in meters.
+   */
+  get distance() {
+    return this._frustumOptions.far;
+  }
+  /**
+   * Sets the field of view of a cone viewshed. Does not have a impact on 360 viewshed.
+   * @param {number} value The field of view in degrees.
+   */
+  set fov(e) {
+    this._frustumOptions.fov = e * O.RADIANS_PER_DEGREE, this._shadowCamera && (this._shadowCamera.frustum.fov = e * O.RADIANS_PER_DEGREE, this._updateShadowMap(), this._viewshedType === w.CONE && this._updatePrimitive());
+  }
+  /**
+   * Returns the field of view.
+   * @returns {number} The field of view in degrees.
+   */
+  get fov() {
+    return this._frustumOptions.fov * O.DEGREES_PER_RADIAN;
+  }
+  /**
+   * Sets the heading of a cone viewshed. Does not have impact on 360 viewshed.
+   * @param {number} value Heading in degrees.
+   */
+  set heading(e) {
+    this._headingPitchRollValues.heading = e * O.RADIANS_PER_DEGREE, this._shadowCamera && (this._shadowCamera.setView({
+      orientation: {
+        heading: e * O.RADIANS_PER_DEGREE,
+        pitch: this._shadowCamera.pitch,
+        roll: 0
+      }
+    }), this._viewshedType === w.CONE && this._updatePrimitive());
+  }
+  /**
+   * Getter for the heading of a cone viewshed.
+   * @returns {number} The heading in degress.
+   */
+  get heading() {
+    return this._headingPitchRollValues.heading * O.DEGREES_PER_RADIAN;
+  }
+  /**
+   * Sets the pitch of a cone viewshed. 0 is horizontal. Does not have impact on 360 viewshed.
+   * @param {number} value The pitch in degrees.
+   */
+  set pitch(e) {
+    if (this._headingPitchRollValues.pitch = e * O.RADIANS_PER_DEGREE, this._shadowCamera) {
+      const t = e * O.RADIANS_PER_DEGREE - this._shadowCamera.pitch;
+      this._shadowCamera.lookUp(t), this._viewshedType === w.CONE && this._updatePrimitive();
+    }
+  }
+  /**
+   * Getter for the pitch of a cone viewshed.
+   * @returns {number} The pitch in degrees.
+   */
+  get pitch() {
+    return this._headingPitchRollValues.pitch * O.DEGREES_PER_RADIAN;
+  }
+  /**
+   * Sets whether the primitive of the viewshed should be shown or not.
+   * @param {boolean} value
+   */
+  set showPrimitive(e) {
+    this._showPrimitive = e, this._updatePrimitive();
+  }
+  /**
+   * Gets if the primitive of the viewshed is shown or not.
+   * @returns {boolean}
+   */
+  get showPrimitive() {
+    return this._showPrimitive;
+  }
+  /**
+   * Retruns the type of the Viewshed.
+   * @returns {ViewshedTypes}
+   */
+  get type() {
+    return this._viewshedType;
+  }
+  /**
+   * Deactivates the viewshed by removing primitve and removing shadowMap.
+   */
+  deactivate() {
+    var e, t, i, o;
+    this._active && (this._removePrimitive(), (e = this._shadowMapChangedListener) == null || e.call(this), ((i = (t = this._cesiumMap) == null ? void 0 : t.getScene()) == null ? void 0 : i.shadowMap) === this._shadowMap && this._cesiumMap.setDefaultShadowMap(), (o = this._shadowMap) == null || o.destroy(), this._shadowCamera = null, this._scene = null, this._cesiumMap = null, this._active = !1);
+  }
+  /**
+   * Activates viewshed. Sets the CesiumMap and adds shadowMapChanged listener to CesiumMap. If viewshed is active but
+   * @param {import("@vcmap/core").CesiumMap} cesiumMap The cesium map to which the shadow map of the viewshed is applied to.
+   */
+  activate(e) {
+    if (this._active || (this._active = !0), e !== this._cesiumMap) {
+      this._cesiumMap = e;
+      const t = e.getScene();
+      if (t)
+        this._shadowCamera = dt(t, this._frustumOptions), this._position && (this.position = this._position), this._scene = t;
+      else
+        throw new Error("CesiumMap contains no scene");
+      this._updateShadowMap(), this._updatePrimitive(), this._shadowMapChangedListener = this._cesiumMap.shadowMapChanged.addEventListener(() => {
+        this.deactivate();
+      });
+    }
+  }
+  /**
+   * Updates the shadow map by creating a new one and applying all the current parameters.
+   */
+  _updateShadowMap() {
+    !this._active || !this._shadowCamera || !this._cesiumMap || !this._scene || (this._shadowMap = new Re({
+      // @ts-ignore
+      context: this._scene.context,
+      lightCamera: this._shadowCamera,
+      enabled: !0,
+      isPointLight: this._viewshedType === w.THREESIXTY,
+      softShadows: !0,
+      fromLightSource: !0,
+      cascadesEnabled: !1,
+      pointLightRadius: this._shadowCamera.frustum.far,
+      maximumDistance: 200,
+      size: 2048
+    }), this._shadowMap.viewshed = this._colors, this._scene.shadowMap = this._shadowMap, this._cesiumMap.setShadowMap(this._shadowMap));
+  }
+  _removePrimitive() {
+    var e;
+    this._primitive && ((e = this._scene) == null || e.primitives.remove(this._primitive), this._primitive.destroy(), this._primitive = null);
+  }
+  _updatePrimitive() {
+    this._showPrimitive && this._active && this._scene ? (this._removePrimitive(), this._primitive = new ct({
+      camera: this._shadowCamera,
+      allowPicking: !1,
+      spot: this._viewshedType === w.CONE
+    }), this._scene.primitives.add(this._primitive)) : this._removePrimitive();
+  }
+  /**
+   * Sets distance and, in case of cone viewsheds, also heading and pitch. Only works when viewshed is **active**.
+   * @param {number[]} target Point to calculate distance, heading and pitch from.
+   */
+  lookAt(e) {
+    if (!this._shadowCamera)
+      return;
+    const t = S.fromDegrees(e[0], e[1], e[2]);
+    if (this.distance = S.distance(this._shadowCamera.position, t), this.type === w.CONE && !t.equals(this._shadowCamera.position)) {
+      const i = new S();
+      S.subtract(t, this._shadowCamera.position, t), S.normalize(t, t), S.normalize(this._shadowCamera.position, i), this._shadowCamera.setView({
+        orientation: {
+          direction: t,
+          up: i
+        }
+      }), this._headingPitchRollValues.heading = this._shadowCamera.heading, this._headingPitchRollValues.pitch = this._shadowCamera.pitch;
+    }
+    this._updatePrimitive();
+  }
+  /**
+   * Returns an object with all the settings of a viewshed instance.
+   * @returns {ViewshedOptions}
+   */
+  toJSON() {
+    return {
+      ...super.toJSON(),
+      viewshedType: this.type,
+      position: this.position,
+      frustumOptions: { ...this._frustumOptions },
+      orientation: { ...this._headingPitchRollValues },
+      colorOptions: {
+        visibleColor: this._colors.visibleColor.toCssHexString(),
+        shadowColor: this._colors.shadowColor.toCssHexString()
+      },
+      showPrimitive: this.showPrimitive,
+      heightOffset: this.heightOffset
+    };
+  }
+  /**
+   * Destroys the viewshed.
+   */
+  destroy() {
+    this.deactivate();
+  }
+};
+Z(E, "MIN_DISTANCE", 10);
+let T = E;
+class ht extends we {
+  /**
+   *
+   * @param {import("./viewshed").default} viewshed
+   */
+  constructor(e) {
+    super(D.CLICKMOVE), this._viewshed = e, this._positioned = new L(), this._finished = new L(), this._position = !1, this.setActive();
+  }
+  get finished() {
+    return this._finished;
+  }
+  get positioned() {
+    return this._positioned;
+  }
+  async pipe(e) {
+    return e.position && (this._position ? (this._viewshed.lookAt(I.mercatorToWgs84(e.position)), e.type & D.CLICK && (this.setActive(!1), this._finished.raiseEvent(null))) : (this._viewshed.position = I.mercatorToWgs84(e.position), e.type & D.CLICK && (this._position = !0, this._positioned.raiseEvent(null)))), e;
+  }
+  destroy() {
+    super.destroy(), this._finished.destroy(), this._positioned.destroy();
+  }
+}
+const V = {
+  ABSOLUTE: "absolute",
+  RELATIVE: "relative"
+}, g = {
+  CREATE: "create",
+  VIEW: "view",
+  EDIT: "edit",
+  MOVE: "move",
+  MULTI_SELECT: "multiSelect"
+}, se = 1.8;
+function ut(s) {
+  const e = new Ce({
+    projection: Ee.toJSON(),
+    zIndex: Ve - 1
+  });
+  ye(e), e.activate();
+  const t = new We(new Be(s));
+  return t.setStyle(new ze({})), e.addFeatures([t]), e.vectorProperties.altitudeMode = Ne.NONE, {
+    layer: e,
+    feature: t,
+    destroy() {
+      t.dispose(), e.destroy();
+    }
+  };
+}
+function U(s, e) {
+  const t = e === V.ABSOLUTE ? D.CLICKMOVE : D.NONE;
+  s.setActive(t), s.pickPosition = t, s.pullPickedPosition = 1.8;
+}
+function ft(s, e, t) {
+  const i = H(null), o = A(null), r = A(null), a = A(V.ABSOLUTE);
+  let l = () => {
+  };
+  const n = H(null);
+  function u(d) {
+    var f, h;
+    o.value && i.value ? (i.value.deactivate(), t.setVisibility(i.value.name, !1)) : (f = i.value) == null || f.destroy(), i.value = d, (h = i.value) == null || h.activate(s.maps.activeMap);
+  }
+  function c(d = !0) {
+    l(), u(null), d && t.clearSelection(), o.value = null, r.value = null;
+  }
+  async function m(d) {
+    c(), await xe();
+    const { eventHandler: f } = s.maps, { featureInteraction: h } = f;
+    i.value = new T(
+      {
+        viewshedType: d,
+        colorOptions: {
+          visibleColor: e.visibleColor,
+          shadowColor: e.shadowColor
+        },
+        heightOffset: a.value === V.ABSOLUTE ? 0 : se
+      },
+      /** @type {import("@vcmap/core").CesiumMap} */
+      s.maps.activeMap
+    );
+    const p = new ht(i.value);
+    p.finished.addEventListener(() => {
+      l(), i.value ? (i.value.showPrimitive = !0, r.value = g.EDIT) : c();
+    });
+    const C = f.addExclusiveInteraction(
+      p,
+      () => {
+        p.destroy();
+      }
+    );
+    U(h, a.value), p.positioned.addEventListener(() => {
+      U(h, V.ABSOLUTE);
+    }), l = () => {
+      C(), p.destroy(), h.setActive(), l = () => {
+      };
+    }, r.value = g.CREATE;
+  }
+  function v(d) {
+    var f;
+    if (i.value && d) {
+      l();
+      const {
+        layer: h,
+        feature: p,
+        destroy: C
+      } = ut(i.value.position);
+      s.layers.add(h), a.value === V.ABSOLUTE ? (n.value = ge(s, h), n.value.setFeatures([p])) : (n.value = _e(s, h), n.value.setFeature(p)), n.value.stopped.addEventListener(() => {
+        l();
+      });
+      const b = (f = p.getGeometry()) == null ? void 0 : f.on("change", () => {
+        i.value ? i.value.position = I.mercatorToWgs84(
+          /** @type {import("ol/geom").Point} */
+          p.getGeometry().getCoordinates()
+        ) : c();
+      });
+      r.value = g.MOVE, l = () => {
+        var N;
+        l = () => {
+        }, b && je(b), (N = n.value) == null || N.stop(), n.value = null, s.layers.remove(h), C(), r.value = g.EDIT;
+      };
+    } else
+      l();
+  }
+  function _(d, f) {
+    l(), i.value !== f && (u(f), a.value = f.heightOffset ? V.RELATIVE : V.ABSOLUTE), o.value = !!f.properties.title, r.value = d, o.value && t.setVisibility(f.name, !0);
+  }
+  const y = [
+    t.collectionComponent.collection.removed.addEventListener(
+      (d) => {
+        var f;
+        t.remove(d.name), ((f = i.value) == null ? void 0 : f.name) === d.name && c();
+      }
+    ),
+    t.renamed.addEventListener(({ item: d, title: f }) => {
+      var p;
+      const h = s.windowManager.get(
+        `${t.collectionComponent.id}-editor`
+      );
+      h && ((p = i.value) == null ? void 0 : p.name) === d.name && (h.state.headerTitle = f);
+    }),
+    t.visibilityChanged.addEventListener((d) => {
+      var h;
+      const f = ((h = i.value) == null ? void 0 : h.name) === d.name;
+      f ? c() : (_(g.VIEW, d), t.clearSelection()), t.setVisibility(d.name, !f);
+    })
+  ];
+  function $(d) {
+    if (!(d === a.value || !i.value)) {
+      if (a.value = d, r.value === g.MOVE && l(), r.value === g.CREATE)
+        U(
+          s.maps.eventHandler.featureInteraction,
+          d
+        ), i.value.heightOffset = d === V.ABSOLUTE ? 0 : se;
+      else if (r.value === g.EDIT) {
+        const { position: f, heightOffset: h } = i.value;
+        d === V.RELATIVE ? s.maps.activeMap.getHeightFromTerrain([I.wgs84ToMercator(f)]).then((p) => {
+          const C = I.mercatorToWgs84(p[0]);
+          i.value && (i.value.heightOffset = f[2] - C[2], i.value.position = C);
+        }) : (i.value.position = [
+          f[0],
+          f[1],
+          f[2] + h
+        ], i.value.heightOffset = 0);
+      }
+    }
+  }
+  return {
+    currentViewshed: i,
+    currentIsPersisted: o,
+    currentEditSession: n,
+    createViewshed: m,
+    viewViewshed(d) {
+      _(g.VIEW, d);
+    },
+    editViewshed(d) {
+      _(g.EDIT, d), o.value && (t.setSelection(d.name), t.collectionComponent.openEditorWindow(d));
+    },
+    persistCurrent() {
+      i.value && (t.add(i.value), o.value = !0, t.setSelection(i.value.name), t.setVisibility(i.value.name, !0));
+    },
+    moveCurrentViewshed: v,
+    setupMultiSelect() {
+      l(), r.value = g.MULTI_SELECT, u(null);
+    },
+    mode: r,
+    heightMode: a,
+    changeHeightMode: $,
+    async placeCurrentFeaturesOnTerrain() {
+      var d, f;
+      if (i.value && ((d = n.value) == null ? void 0 : d.type) === me.EDIT_FEATURES && s.maps.activeMap instanceof B) {
+        const p = (await s.maps.activeMap.getHeightFromTerrain([
+          I.wgs84ToMercator((f = i.value) == null ? void 0 : f.position)
+        ]))[0][2] - i.value.position[2];
+        n.value.translate(0, 0, p);
+      }
+    },
+    stop: c,
+    destroy() {
+      c(), y.forEach((d) => d());
+    }
+  };
+}
+function he(s, e, t, i, o, r, a, l) {
+  var n = typeof s == "function" ? s.options : s;
+  e && (n.render = e, n.staticRenderFns = t, n._compiled = !0), i && (n.functional = !0), r && (n._scopeId = "data-v-" + r);
+  var u;
+  if (a ? (u = function(v) {
+    v = v || // cached call
+    this.$vnode && this.$vnode.ssrContext || // stateful
+    this.parent && this.parent.$vnode && this.parent.$vnode.ssrContext, !v && typeof __VUE_SSR_CONTEXT__ < "u" && (v = __VUE_SSR_CONTEXT__), o && o.call(this, v), v && v._registeredComponents && v._registeredComponents.add(a);
+  }, n._ssrRegister = u) : o && (u = l ? function() {
+    o.call(
+      this,
+      (n.functional ? this.parent : this).$root.$options.shadowRoot
+    );
+  } : o), u)
+    if (n.functional) {
+      n._injectStyles = u;
+      var c = n.render;
+      n.render = function(_, y) {
+        return u.call(y), c(_, y);
+      };
+    } else {
+      var m = n.beforeCreate;
+      n.beforeCreate = m ? [].concat(m, u) : [u];
+    }
+  return {
+    exports: s,
+    options: n
+  };
+}
+const vt = {
+  distance: [T.MIN_DISTANCE, 2e3],
+  fov: [25, 85],
+  heading: [0, 360],
+  pitch: [-90, 90]
+}, pt = {
+  components: {
+    VcsTextField: Ge,
+    VContainer: ae,
+    VRow: le,
+    VCol: ce,
+    VcsSlider: Ue,
+    VcsLabel: oe,
+    VcsFormSection: ne,
+    VDivider: tt,
+    VcsSelect: re,
+    VcsFormButton: He,
+    VcsFeatureTransforms: Xe
+  },
+  name: "ViewshedWindow",
+  props: {
+    getViewshed: {
+      type: Function,
+      required: !1,
+      default: void 0
+    },
+    selection: {
+      type: Object,
+      required: !1,
+      default: void 0
+    }
+  },
+  setup(s) {
+    const e = (
+      /** @type {import("./viewshedManager.js").ViewshedManager} */
+      ie("manager")
+    ), t = (
+      /** @type {import("@vcmap/ui").VcsUiApp} */
+      ie("vcsApp")
+    ), {
+      currentViewshed: i,
+      mode: o,
+      currentIsPersisted: r
+    } = e, a = A(s.selection);
+    let l = () => {
+    };
+    const n = j({
+      X: void 0,
+      Y: void 0,
+      Z: void 0
+    }), u = H();
+    let c = () => {
+    };
+    const m = j({
+      showPrimitive: !1,
+      distance: void 0,
+      fov: void 0,
+      heading: void 0,
+      pitch: void 0
+    }), v = A();
+    function _() {
+      i.value && (n.X = i.value.position[0], n.Y = i.value.position[1], n.Z = e.heightMode.value === V.ABSOLUTE ? i.value.position[2] : i.value.heightOffset);
+    }
+    function y() {
+      _(), i.value && (m.distance = i.value.distance, m.fov = i.value.fov, m.heading = i.value.heading, m.pitch = i.value.pitch, m.showPrimitive = i.value.showPrimitive, v.value = i.value.type);
+    }
+    De(() => {
+      i.value && o.value !== g.CREATE && y();
+    }), R(
+      i,
+      () => {
+        i.value && (l(), l = i.value.positionChanged.addEventListener(() => {
+          _(), c();
+        }));
+      },
+      { immediate: !0 }
+    );
+    async function $() {
+      var C, b;
+      (C = i.value) == null || C.deactivate();
+      const h = (
+        /** @type {import("@vcmap/core").CesiumMap} */
+        (b = t.maps.activeMap.getScene()) == null ? void 0 : b.camera
+      ), p = h == null ? void 0 : h.changed.addEventListener(() => {
+        c();
+      });
+      c = () => {
+        var N;
+        p == null || p(), u.value = null, (N = i.value) == null || N.activate(t.maps.activeMap), c = () => {
+        };
+      };
+    }
+    Le(() => {
+      var p;
+      const h = (p = s.getViewshed) == null ? void 0 : p.call(s);
+      h && e.editViewshed(h);
+    }), Fe(() => {
+      l(), c(), r.value || ((o.value === g.EDIT || o.value === g.MOVE) && i.value ? e.viewViewshed(i.value) : o.value === g.CREATE && e.stop()), a.value && (a.value.length > 1 ? e.setupMultiSelect() : a.value.length === 1 && i.value ? e.viewViewshed(i.value) : (
+        // when a persited viewshed is deselected, stops plugin
+        !a.value.length && o.value === g.EDIT && e.stop(!1)
+      ));
+    }), y();
+    function d(h, p) {
+      c(), i.value && (m[h] = p, i.value[h] = p);
+    }
+    const f = ke(() => {
+      const h = [];
+      return v.value === w.CONE && h.push({
+        name: "jumpToViewpoint",
+        title: u.value ? "viewshed.returnToViewpoint" : "viewshed.jumpToViewpoint",
+        icon: "mdi-human-male",
+        active: !!u.value,
+        async callback() {
+          var p, C, b;
+          e.moveCurrentViewshed(!1), i.value && !u.value ? (u.value = await ((p = t.maps.activeMap) == null ? void 0 : p.getViewpoint()), await ((C = t.maps.activeMap) == null ? void 0 : C.gotoViewpoint(
+            new be({
+              groundPosition: [
+                i.value.position[0],
+                i.value.position[1],
+                i.value.position[2] + i.value.heightOffset
+              ],
+              heading: i.value.heading,
+              pitch: i.value.pitch,
+              distance: 0,
+              animate: !0
+              // if not animate, async does not work and the cameraChanged listener is triggered immediately. alternatively set timeout
+            })
+          )), $()) : u.value && ((b = t.maps.activeMap) == null || b.gotoViewpoint(u.value), c());
+        }
+      }), h.push({
+        name: "moveViewshed",
+        title: "viewshed.move",
+        icon: e.heightMode.value === V.RELATIVE ? "$vcsEditVertices" : "mdi-axis-arrow",
+        active: o.value === g.MOVE,
+        callback() {
+          e.moveCurrentViewshed(
+            o.value !== g.MOVE
+          );
+        }
+      }), h.unshift({
+        name: "showPrimitive",
+        title: "viewshed.showPrimitive",
+        icon: "mdi-eye",
+        active: m.showPrimitive,
+        callback() {
+          this.active = !this.active, d("showPrimitive", this.active);
+        }
+      }), h;
+    });
+    return {
+      position: n,
+      setPosition(h, p, C) {
+        if (c(), !!i.value) {
+          if (C === 2 && e.heightMode.value === V.RELATIVE)
+            i.value.heightOffset = Number(h);
+          else {
+            const b = [...i.value.position];
+            b[C] = Number(h), i.value.position = b;
+          }
+          n[p] = Number(h);
+        }
+      },
+      parameters: m,
+      setParameter: d,
+      parameterRanges: vt,
+      ViewshedPluginModes: g,
+      viewshedMode: o,
+      currentIsPersisted: r,
+      viewshedType: v,
+      ViewshedTypes: w,
+      HeightModes: V,
+      heightMode: e.heightMode,
+      TransformationMode: Me,
+      changeHeightMode: e.changeHeightMode,
+      async createNewViewshed() {
+        await e.createViewshed(v.value);
+      },
+      addToMyWorkspace: () => e.persistCurrent(),
+      cancel: () => e.stop(),
+      headerActions: f
+    };
+  }
+};
+var wt = function() {
+  var e = this, t = e._self._c;
+  return t("div", [e.viewshedMode === e.ViewshedPluginModes.CREATE ? t("div", { staticClass: "px-2 py-1" }, [e._v(" " + e._s(e.$t("viewshed.createDescription")) + " ")]) : e.viewshedMode === e.ViewshedPluginModes.EDIT || e.viewshedMode === e.ViewshedPluginModes.MOVE ? t("VcsFormSection", { attrs: { "header-actions": e.headerActions, heading: "viewshed.viewpoint", "action-button-list-overflow-count": 3 } }, [t("v-container", { staticClass: "px-1 py-0" }, [t("v-row", { attrs: { "no-gutters": "" } }, [t("span", { staticClass: "px-1 py-0" }, [e._v(e._s(e.$t("viewshed.position")))])]), e.viewshedMode === e.ViewshedPluginModes.MOVE && e.heightMode === e.HeightModes.ABSOLUTE ? t("v-row", { attrs: { "no-gutters": "" } }, [t("VcsFeatureTransforms", { attrs: { "transformation-mode": e.TransformationMode.TRANSLATE, "feature-properties": { altitudeMode: "absolute" }, "allow-z-input": !0 } })], 1) : t("v-row", { attrs: { "no-gutters": "" } }, e._l(e.position, function(i, o, r) {
+    return t("v-col", { key: r, staticClass: "pb-1" }, [t("VcsTextField", { attrs: { value: i, type: "number", prefix: o, "show-spin-buttons": !0, step: o === "Z" ? 1 : 1e-4, unit: o === "Z" ? "m" : "°", decimals: o === "Z" ? 2 : 8, disabled: e.viewshedMode === e.ViewshedPluginModes.MOVE && !(o === "Z" && e.heightMode === e.HeightModes.RELATIVE) }, on: { input: (a) => e.setPosition(a, o, r) } })], 1);
+  }), 1)], 1)], 1) : e._e(), t("v-divider"), t("v-container", { staticClass: "px-1 py-0" }, [t("v-row", { attrs: { "no-gutters": "" } }, [t("v-col", [t("VcsLabel", [e._v(" " + e._s(e.$t("viewshed.heightMode")) + " ")])], 1), t("v-col", [t("VcsSelect", { attrs: { items: Object.values(e.HeightModes).map((i) => ({
+    value: i,
+    text: `viewshed.${i}`
+  })), value: e.heightMode }, on: { input: e.changeHeightMode } })], 1)], 1)], 1), e.viewshedMode === e.ViewshedPluginModes.EDIT || e.viewshedMode === e.ViewshedPluginModes.MOVE ? t("v-container", { staticClass: "px-1 pt-0 pb-2" }, e._l(e.parameters, function(i, o) {
+    return t("v-row", { key: o, attrs: { "no-gutters": "" } }, [o === "distance" || e.viewshedType === e.ViewshedTypes.CONE && o !== "showPrimitive" ? t("v-col", [t("v-row", { staticClass: "pr-1", attrs: { "no-gutters": "" } }, [t("v-col", [t("VcsLabel", { attrs: { "html-for": o } }, [e._v(" " + e._s(e.$t(`viewshed.${o}`)) + " ")])], 1), t("v-col", { staticClass: "d-flex justify-end align-center" }, [o === "distance" ? t("span", [e._v(e._s(`${i} m`))]) : t("span", [e._v(e._s(`${i} °`))])])], 1), t("v-row", { attrs: { "no-gutters": "" } }, [t("v-col", [t("VcsSlider", { attrs: { id: o, value: i, type: "number", step: "1", min: e.parameterRanges[o][0], max: e.parameterRanges[o][1], height: "15" }, on: { input: (r) => e.setParameter(o, r) } })], 1)], 1)], 1) : e._e()], 1);
+  }), 1) : e._e(), t("v-divider"), e.viewshedMode === e.ViewshedPluginModes.EDIT || e.viewshedMode === e.ViewshedPluginModes.MOVE ? t("div", { staticClass: "d-flex w-full justify-space-between px-2 pt-2 pb-1" }, [t("VcsFormButton", { attrs: { tooltip: "viewshed.addToMyWorkspace", icon: "$vcsComponentsPlus", disabled: e.currentIsPersisted || void 0 }, on: { click: function(i) {
+    return e.addToMyWorkspace();
+  } } }), t("VcsFormButton", { attrs: { variant: "filled" }, on: { click: function(i) {
+    return e.createNewViewshed();
+  } } }, [e._v(" " + e._s(e.$t("viewshed.new")) + " ")])], 1) : e.viewshedMode === e.ViewshedPluginModes.CREATE ? t("div", { staticClass: "d-flex w-full justify-end px-2 pt-2 pb-1" }, [t("VcsFormButton", { attrs: { variant: "filled" }, on: { click: function(i) {
+    return e.cancel();
+  } } }, [e._v(" " + e._s(e.$t("viewshed.cancel")) + " ")])], 1) : e._e()], 1);
+}, mt = [], gt = /* @__PURE__ */ he(
+  pt,
+  wt,
+  mt,
+  !1,
+  null,
+  null,
+  null,
+  null
+);
+const _t = gt.exports, P = "@vcmap/viewshed", Ct = "2.0.1", Et = "^5.1", Y = {
+  [w.CONE]: "$vcsViewshed",
+  [w.THREESIXTY]: "$vcsViewshedCone"
+};
+function Vt(s, e, t) {
+  const i = A(), o = A(), r = `${t.id}-editor`, a = {
+    component: _t,
+    provides: {
+      manager: s
+    },
+    state: {
+      headerTitle: i,
+      headerIcon: o,
+      styles: { width: "280px", height: "auto" },
+      infoUrlCallback: e.getHelpUrlCallback("tools/viewshedTool.html")
+    }
+  };
+  Ke(e, t, {
+    editor: (v) => ({
+      ...a,
+      props: {
+        selection: t.selection,
+        getViewshed: () => t.collection.getByKey(v.name)
+      }
+    })
+  });
+  function l() {
+    s.currentViewshed.value && (o.value = Y[s.currentViewshed.value.type], s.currentIsPersisted.value ? i.value = s.currentViewshed.value.properties.title : s.mode.value === g.CREATE ? i.value = [
+      "viewshed.create",
+      `viewshed.${s.currentViewshed.value.type}`
+    ] : i.value = [
+      "viewshed.temporary",
+      `viewshed.${s.currentViewshed.value.type}`
+    ]);
+  }
+  function n() {
+    l(), s.currentViewshed.value && !s.currentIsPersisted.value && (s.mode.value === g.EDIT || s.mode.value === g.MOVE || s.mode.value === g.CREATE) && (e.windowManager.has(r) || e.windowManager.add(
+      {
+        ...a,
+        id: r,
+        parentId: "category-manager",
+        slot: Ye.DYNAMIC_LEFT
+      },
+      P
+    ));
+  }
+  const u = R(s.currentViewshed, (v) => {
+    v && n();
+  }), c = R(s.currentIsPersisted, (v) => {
+    v && l();
+  }), m = R(s.mode, () => {
+    s.mode.value ? n() : e.windowManager.remove(r);
+  });
+  return {
+    destroy() {
+      e.windowManager.remove(r), u(), m(), c();
+    }
+  };
+}
+function yt(s, e, t, i) {
+  const o = {
+    type: Je.SELECT,
+    action: j({
+      name: t,
+      currentIndex: 0,
+      active: !1,
+      background: !1,
+      disabled: !1,
+      callback() {
+        if (this.active)
+          this.background && e.currentViewshed.value ? e.editViewshed(e.currentViewshed.value) : e.stop();
+        else {
+          const n = this.tools[this.currentIndex].name;
+          e.createViewshed(n);
+        }
+      },
+      selected(n) {
+        if (n !== this.currentIndex) {
+          this.currentIndex = n;
+          const u = this.tools[this.currentIndex].name;
+          e.createViewshed(u);
+        }
+      },
+      tools: i.flatMap((n) => n === w.CONE ? {
+        name: w.CONE,
+        icon: Y[w.CONE],
+        title: `viewshed.${w.CONE}`
+      } : n === w.THREESIXTY ? {
+        name: w.THREESIXTY,
+        icon: Y[w.THREESIXTY],
+        title: `viewshed.${w.THREESIXTY}`
+      } : [])
+    })
+  }, r = R(e.mode, (n) => {
+    n === g.VIEW ? (o.action.background = !0, o.action.active = !0) : n ? (o.action.background = !1, o.action.active = !0) : (o.action.background = !1, o.action.active = !1);
+  }), a = R(
+    e.currentViewshed,
+    (n) => {
+      n && (o.action.currentIndex = o.action.tools.findIndex(
+        (u) => u.name === n.type
+      ));
+    }
+  ), l = s.maps.mapActivated.addEventListener((n) => {
+    n instanceof B ? o.action.disabled = !1 : (o.action.disabled = !0, e.stop());
+  });
+  return {
+    destroy() {
+      r(), a(), l();
+    },
+    toolbox: o
+  };
+}
+function bt(s, e, t, i) {
+  z(i, [Object.values(w)]);
+  const { toolbox: o, destroy: r } = yt(s, e, t, i), a = s.toolboxManager.add(o, t).id;
+  return () => {
+    s.toolboxManager.remove(a), r();
+  };
+}
+class J extends Te {
+  static get className() {
+    return "ViewshedCategory";
+  }
+  async _deserializeItem(e) {
+    var i;
+    const t = (
+      /** @type {import("@vcmap/core").CesiumMap | undefined} */
+      (i = this._app) == null ? void 0 : i.maps.getByType(B.className)[0]
+    );
+    if (t)
+      return new T(e, t);
+    throw new Error("No CesiumMap available");
+  }
+}
+function Mt(s, e) {
+  let t, i = 0;
+  const o = new Set(
+    e.filter((r) => r.type === s).map((r) => r.properties.title)
+  );
+  do
+    i += 1, o.has(`${s}-${i}`) || (t = `${s}-${i}`);
+  while (!t);
+  return t;
+}
+async function Tt(s) {
+  const e = new L(), t = new L(), { collectionComponent: i, category: o } = await s.categoryManager.requestCategory(
+    {
+      type: J.className,
+      name: "Viewsheds",
+      title: "Viewsheds"
+    },
+    P,
+    {
+      selectable: !0,
+      renamable: !0,
+      removable: !0
+    }
+  ), r = (c, m, v) => {
+    v.title = c.properties.title, v.titleChanged = (_) => {
+      c.properties.title = _, v.title = _, e.raiseEvent({ item: c, title: _ });
+    }, v.actions.push(
+      j({
+        name: "visibilityAction",
+        icon: "$vcsCheckbox",
+        callback() {
+          t.raiseEvent(c);
+        }
+      })
+    );
+  };
+  s.categoryManager.addMappingFunction(
+    () => !0,
+    r,
+    P,
+    [i.id]
+  );
+  const { action: a, destroy: l } = Ze(
+    i.selection,
+    () => {
+      const c = i.selection.value.map(
+        (m) => i.collection.getByKey(m.name)
+      );
+      qe(JSON.stringify(c), "viewsheds.json");
+    },
+    P
+  ), { action: n, destroy: u } = Qe(
+    async (c) => {
+      const m = c.map((v) => {
+        const _ = new FileReader();
+        return new Promise((y, $) => {
+          _.onload = () => {
+            try {
+              JSON.parse(_.result).forEach((f) => {
+                const h = new T(f);
+                o.collection.add(h);
+              }), y();
+            } catch (d) {
+              $(d);
+            }
+          }, _.readAsText(v);
+        });
+      });
+      await Promise.all(m);
+    },
+    s.windowManager,
+    P,
+    "category-manager"
+  );
+  return i.addActions([a, n]), {
+    renamed: e,
+    visibilityChanged: t,
+    setSelection(c) {
+      c && (i.selection.value = i.items.value.filter((m) => c === m.name));
+    },
+    clearSelection() {
+      i.selection.value.length && (i.selection.value = []);
+    },
+    setVisibility(c, m) {
+      const v = i.items.value.find(
+        (_) => c === _.name
+      );
+      if (v) {
+        const _ = v.actions.find(
+          (y) => y.name === "visibilityAction"
+        );
+        _ && (_.icon = m ? "$vcsCheckboxChecked" : "$vcsCheckbox");
+      }
+    },
+    add(c) {
+      c.properties.title = Mt(
+        c.type,
+        /** @type {import("./viewshed.js").default[]} */
+        [
+          ...o.collection
+        ]
+      ), o.collection.add(c);
+    },
+    remove(c) {
+      const m = o.collection.getByKey(c);
+      m && o.collection.remove(m);
+    },
+    collectionComponent: i,
+    destroy() {
+      s.categoryManager.removeOwner(P), e.destroy(), t.destroy(), l(), u();
+    }
+  };
+}
+function F() {
+  return {
+    visibleColor: T.getDefaultOptions().visibleColor,
+    shadowColor: T.getDefaultOptions().shadowColor,
+    tools: [...Object.values(w)]
+  };
+}
+const Ot = {
+  name: "ViewshedConfigEditor",
+  title: "Viewshed Editor",
+  components: {
+    AbstractConfigEditor: et,
+    VcsFormSection: ne,
+    VContainer: ae,
+    VRow: le,
+    VCol: ce,
+    VcsLabel: oe,
+    VcsSelect: re,
+    VColorPicker: it
+  },
+  props: {
+    getConfig: {
+      type: Function,
+      required: !0
+    },
+    setConfig: {
+      type: Function,
+      required: !0
+    }
+  },
+  setup(s) {
+    const e = A({});
+    s.getConfig().then((i) => {
+      e.value = Object.assign(F(), i);
+    });
+    async function t() {
+      await s.setConfig(e.value);
+    }
+    return {
+      localConfig: e,
+      ViewshedTypes: w,
+      apply: t,
+      toolItems: Object.values(w).map((i) => ({
+        value: i,
+        text: `viewshed.${i}`
+      }))
+    };
+  }
+};
+var St = function() {
+  var e = this, t = e._self._c;
+  return t("AbstractConfigEditor", e._b({ on: { submit: e.apply } }, "AbstractConfigEditor", { ...e.$attrs, ...e.$props }, !1), [e.localConfig ? t("VcsFormSection", { attrs: { heading: "viewshed.editor.general" } }, [t("v-container", { staticClass: "px-1 py-0" }, [t("v-row", { attrs: { "no-gutters": "" } }, [t("v-col", [t("VcsLabel", { attrs: { "html-for": "viewshed-editor-tools" } }, [e._v(e._s(e.$t("viewshed.editor.tools")))])], 1), t("v-col", [t("VcsSelect", { attrs: { id: "viewshed-tools", items: e.toolItems, multiple: !0 }, model: { value: e.localConfig.tools, callback: function(i) {
+    e.$set(e.localConfig, "tools", i);
+  }, expression: "localConfig.tools" } })], 1)], 1), t("v-row", { attrs: { "no-gutters": "" } }, [t("v-col", [t("VcsLabel", { attrs: { "html-for": "viewshed-editor-visible-color" } }, [e._v(e._s(e.$t("viewshed.editor.visibleColor")))])], 1), t("v-col", [t("VColorPicker", { attrs: { mode: "rgba" }, model: { value: e.localConfig.visibleColor, callback: function(i) {
+    e.$set(e.localConfig, "visibleColor", i);
+  }, expression: "localConfig.visibleColor" } })], 1)], 1), t("v-row", { attrs: { "no-gutters": "" } }, [t("v-col", [t("VcsLabel", { attrs: { "html-for": "viewshed-editor-shadow-color" } }, [e._v(e._s(e.$t("viewshed.editor.shadowColor")))])], 1), t("v-col", [t("VColorPicker", { attrs: { mode: "rgba" }, model: { value: e.localConfig.shadowColor, callback: function(i) {
+    e.$set(e.localConfig, "shadowColor", i);
+  }, expression: "localConfig.shadowColor" } })], 1)], 1)], 1)], 1) : e._e()], 1);
+}, Pt = [], At = /* @__PURE__ */ he(
+  Ot,
+  St,
+  Pt,
+  !1,
+  null,
+  null,
+  null,
+  null
+);
+const It = At.exports;
+function kt(s) {
+  let e, t = () => {
+  };
+  return {
+    get name() {
+      return P;
+    },
+    get version() {
+      return Ct;
+    },
+    get mapVersion() {
+      return Et;
+    },
+    /**
+     * @param {import("@vcmap/ui").VcsUiApp} vcsUiApp
+     * @param {ViewshedPluginState=} state
+     * @returns {Promise<void>}
+     */
+    async initialize(i, o) {
+      i.categoryClassRegistry.registerClass(
+        this[Oe],
+        J.className,
+        J
+      );
+      const r = await Tt(i);
+      e = ft(
+        i,
+        s,
+        r
+      );
+      const a = bt(
+        i,
+        e,
+        P,
+        s.tools || F().tools
+      ), { destroy: l } = Vt(
+        e,
+        i,
+        r.collectionComponent
+      );
+      t = () => {
+        a(), l(), r.destroy();
+      };
+      const { activeMap: n } = i.maps;
+      if (o != null && o.mode && o.currentViewshed && n instanceof B) {
+        const u = new T(o.currentViewshed, n);
+        o.mode === g.VIEW ? e.viewViewshed(u) : e.editViewshed(u);
+      }
+    },
+    /**
+     * should return all default values of the configuration
+     * @returns {ViewshedPluginOptions}
+     */
+    getDefaultOptions: F,
+    /**
+     * should return the plugin's serialization excluding all default values
+     * @returns {ViewshedPluginOptions}
+     */
+    toJSON() {
+      const i = {};
+      return s.tools && F().tools.length !== s.tools.length && (i.tools = [...s.tools]), s.shadowColor && s.shadowColor !== T.getDefaultOptions().shadowColor && (i.shadowColor = s.shadowColor), s.visibleColor && s.visibleColor !== T.getDefaultOptions().visibleColor && (i.visibleColor = s.visibleColor), i;
+    },
+    /**
+     * should return the plugins state
+     * @returns {ViewshedPluginState}
+     */
+    getState() {
+      var i;
+      return {
+        mode: e.mode.value,
+        currentViewshed: (i = e.currentViewshed.value) == null ? void 0 : i.toJSON()
+      };
+    },
+    /**
+     * components for configuring the plugin and/ or custom items defined by the plugin
+     * @returns {Array<import("@vcmap/ui").PluginConfigEditor>}
+     */
+    getConfigEditors() {
+      return [{ component: It }];
+    },
+    destroy: t,
+    i18n: {
+      en: {
+        viewshed: {
+          distance: "Distance",
+          fov: "Field of view",
+          heading: "Heading",
+          pitch: "Pitch",
+          position: "Position",
+          showPrimitive: "Show viewpoint",
+          viewpoint: "Viewpoint",
+          viewshed: "Viewshed",
+          heightMode: "Height mode",
+          relative: "Relativ to ground",
+          absolute: "Absolute",
+          new: "New",
+          cancel: "Cancel",
+          [w.CONE]: "Cone Viewshed",
+          [w.THREESIXTY]: "360° Viewshed",
+          create: "Create",
+          addToMyWorkspace: "Add to My Workspace",
+          temporary: "Temporary",
+          jumpToViewpoint: "Jump to viewpoint",
+          returnToViewpoint: "Return to previous viewpoint",
+          move: "Move viewpoint",
+          createDescription: "Click the map twice. First click places the origin, second defines the distance and direction of the viewshed.",
+          remove: "Remove",
+          editor: {
+            general: "General",
+            visibleColor: "Visible color",
+            shadowColor: "Shadow color",
+            tools: "Tools"
+          }
+        }
+      },
+      de: {
+        viewshed: {
+          distance: "Distanz",
+          fov: "Sichtfeld",
+          heading: "Ausrichtung",
+          pitch: "Neigung",
+          position: "Position",
+          showPrimitive: "Viewpoint zeigen",
+          viewpoint: "Viewpoint",
+          viewshed: "Viewshed",
+          heightMode: "Höhenmodus",
+          relative: "Relativ zum Gelände",
+          absolute: "Absolut",
+          new: "Neu",
+          cancel: "Abbrechen",
+          [w.CONE]: "Kegel Viewshed",
+          [w.THREESIXTY]: "360° Viewshed",
+          create: "Erzeuge",
+          addToMyWorkspace: "Zu Mein Arbeitsbereich hinzufügen",
+          temporary: "Temporärer",
+          jumpToViewpoint: "Zu Viewpoint springen",
+          returnToViewpoint: "Zu vorherigem Viewpoint zurück springen",
+          move: "Viewpoint verschieben",
+          createDescription: "Klicke zweimal in die Karte. Der erste Klick platziert den Ursprung, der zweite die Distanz und die Richtung des Viewsheds.",
+          remove: "Entfernen",
+          editor: {
+            general: "Generelles",
+            visibleColor: "Sichtbarer Bereich",
+            shadowColor: "Schatten Bereich",
+            tools: "Werkzeuge"
+          }
+        }
+      }
+    }
+  };
+}
+export {
+  kt as default
+};