@vcmap/core 5.1.5 → 5.2.0

package/src/featureProvider/wmsFeatureProvider.ts

@@ -1,10 +1,7 @@
 import GML2 from 'ol/format/GML2.js';
 import type { Options as GMLOptions } from 'ol/format/GMLBase.js';
 import WFS from 'ol/format/WFS.js';
-import GeoJSON, {
-  type GeoJSONObject,
-  type Options as GeoJSONOptions,
-} from 'ol/format/GeoJSON.js';
+import GeoJSON, { type Options as GeoJSONOptions } from 'ol/format/GeoJSON.js';
 import GML3 from 'ol/format/GML3.js';
 import Point from 'ol/geom/Point.js';
 import { getTransform, type Projection as OLProjection } from 'ol/proj.js';
@@ -24,7 +21,7 @@ import Projection, {
 import type { WMSSourceOptions } from '../layer/wmsHelpers.js';
 import { getWMSSource } from '../layer/wmsHelpers.js';
 import Extent, { ExtentOptions } from '../util/extent.js';
-import { getInitForUrl, requestJson } from '../util/fetch.js';
+import { getInitForUrl, requestUrl } from '../util/fetch.js';
 import { featureProviderClassRegistry } from '../classRegistry.js';
 import { TilingScheme } from '../layer/rasterLayer.js';
 
@@ -206,7 +203,7 @@ class WMSFeatureProvider extends AbstractFeatureProvider {
   }
 
   featureResponseCallback(
-    data: GeoJSONObject,
+    data: Document | Element | ArrayBuffer | any | string,
     coordinate: Coordinate,
   ): Feature[] {
     let features: Feature[];
@@ -259,9 +256,10 @@ class WMSFeatureProvider extends AbstractFeatureProvider {
 
     if (url) {
       const init = getInitForUrl(url, headers);
-      let data: GeoJSONObject;
+      let data: string;
       try {
-        data = await requestJson<GeoJSONObject>(url, init);
+        const response = await requestUrl(url, init);
+        data = await response.text();
       } catch (ex) {
         this.getLogger().error(`Failed fetching WMS FeatureInfo ${url}`);
         return [];

package/src/interaction/abstractInteraction.ts

@@ -15,6 +15,7 @@ import {
   PointerKeyType,
 } from './interactionType.js';
 import type VcsMap from '../map/vcsMap.js';
+import VcsEvent from '../vcsEvent.js';
 
 export type MapEvent = {
   pointerEvent: PointerEventType;
@@ -70,6 +71,10 @@ export type InteractionEvent = MapEvent & {
    * whether the position is exact, eg with translucentDepthPicking on
    */
   exactPosition?: boolean;
+  /**
+   * called when the event chain has ended in which this event was fired.
+   */
+  chainEnded?: VcsEvent<void>;
 };
 
 export type EventAfterEventHandler = Omit<

package/src/interaction/eventHandler.ts

@@ -146,6 +146,14 @@ class EventHandler {
     return this._modifierChanged;
   }
 
+  /**
+   * if an exclusive Interaction is set, this will return the id of the exclusive Interaction
+   * This can be used to add another Interaction to the same Id
+   */
+  get exclusiveInteractionId(): string | undefined {
+    return this._exclusiveInteraction?.id;
+  }
+
   /**
    * Add a dynamic interaction to the interaction chain. This is the default methodology for
    * user map interactions, such as drawing or measuring. If another exclusive interaction is added,
@@ -296,7 +304,10 @@ class EventHandler {
       return;
     }
 
-    const actualEvent: Partial<InteractionEvent> & MapEvent = event;
+    const actualEvent: Partial<InteractionEvent> & MapEvent = {
+      ...event,
+      chainEnded: new VcsEvent(),
+    };
     if (this._dragging) {
       actualEvent.type = EventType.DRAGEND;
       actualEvent.key = this._dragging.key;
@@ -328,7 +339,10 @@ class EventHandler {
   }
 
   private _mouseMove(event: MapEvent): void {
-    let actualEvent: Partial<InteractionEvent> & MapEvent = event;
+    let actualEvent: Partial<InteractionEvent> & MapEvent = {
+      ...event,
+      chainEnded: new VcsEvent(),
+    };
     if (this._lastDown) {
       if (this._dragging) {
         actualEvent.type = EventType.DRAG;
@@ -339,7 +353,11 @@ class EventHandler {
         !this._dragging &&
         Date.now() - (this._lastDown.time as number) > this.dragDuration
       ) {
-        actualEvent = { type: EventType.DRAGSTART, ...this._lastDown };
+        actualEvent = {
+          type: EventType.DRAGSTART,
+          ...this._lastDown,
+          chainEnded: new VcsEvent(),
+        };
         this._dragging = actualEvent;
         this._startChain(actualEvent as InteractionEvent, true);
       }
@@ -399,22 +417,21 @@ class EventHandler {
       this._running = true;
       this._interactionChain
         .pipe(event)
-        .then(this._endChain.bind(this))
         .catch((error) => {
           getLogger().error((error as Error).message);
-          this._endChain();
+        })
+        .finally(() => {
+          event.chainEnded?.raiseEvent();
+          event.chainEnded?.destroy();
+          this._running = false;
+          const nextEvent = this._eventQueue.shift();
+          if (nextEvent) {
+            this._startChain(nextEvent);
+          }
         });
     }
   }
 
-  private _endChain(): void {
-    this._running = false;
-    const nextEvent = this._eventQueue.shift();
-    if (nextEvent) {
-      this._startChain(nextEvent);
-    }
-  }
-
   /**
    * Destroys the event handler and its interaction chain.
    */

package/src/map/baseOLMap.ts

@@ -17,6 +17,7 @@ import {
 import { mapClassRegistry } from '../classRegistry.js';
 import type LayerCollection from '../util/layerCollection.js';
 import type Layer from '../layer/layer.js';
+import { DisableMapControlOptions } from '../util/mapCollection.js';
 
 export function ensureLayerInCollection(
   layers: OLCollection<OLLayer>,
@@ -204,11 +205,11 @@ class BaseOLMap extends VcsMap<OLLayer> {
     }
   }
 
-  disableMovement(prevent: boolean): void {
+  disableMovement(prevent: boolean | DisableMapControlOptions): void {
     super.disableMovement(prevent);
     if (this._olMap) {
       this._olMap.getInteractions().forEach((i) => {
-        i.setActive(!prevent);
+        i.setActive(!this.movementPointerEventsDisabled);
       });
     }
   }

package/src/map/cesiumMap.ts

@@ -57,6 +57,7 @@ import { mapClassRegistry } from '../classRegistry.js';
 import type LayerCollection from '../util/layerCollection.js';
 import type Layer from '../layer/layer.js';
 import VcsEvent from '../vcsEvent.js';
+import { DisableMapControlOptions } from '../util/mapCollection.js';
 
 export type CesiumMapOptions = VcsMapOptions & {
   /**
@@ -850,7 +851,11 @@ class CesiumMap extends VcsMap<CesiumVisualisationType> {
     viewpoint: Viewpoint,
     optMaximumHeight?: number,
   ): Promise<void> {
-    if (this.movementDisabled || !viewpoint.isValid() || !this._cesiumWidget) {
+    if (
+      this.movementApiCallsDisabled ||
+      !viewpoint.isValid() ||
+      !this._cesiumWidget
+    ) {
       return;
     }
 
@@ -980,10 +985,12 @@ class CesiumMap extends VcsMap<CesiumVisualisationType> {
     );
   }
 
-  disableMovement(bool: boolean): void {
-    super.disableMovement(bool);
+  disableMovement(prevent: boolean | DisableMapControlOptions): void {
+    super.disableMovement(prevent);
+
     if (this._cesiumWidget) {
-      this._cesiumWidget.scene.screenSpaceCameraController.enableInputs = !bool;
+      this._cesiumWidget.scene.screenSpaceCameraController.enableInputs =
+        !this.movementPointerEventsDisabled;
     }
   }
 

package/src/map/obliqueMap.ts

@@ -280,7 +280,7 @@ class ObliqueMap extends BaseOLMap {
   ): Promise<void> {
     check(obliqueCollection, ObliqueCollection);
 
-    if (this.movementDisabled) {
+    if (this.movementApiCallsDisabled) {
       return;
     }
 
@@ -329,7 +329,7 @@ class ObliqueMap extends BaseOLMap {
     imageName: string,
     optCenter?: Coordinate,
   ): Promise<void> {
-    if (this.movementDisabled || !this.initializedPromise) {
+    if (this.movementApiCallsDisabled || !this.initializedPromise) {
       return;
     }
     await this.initializedPromise;
@@ -414,7 +414,7 @@ class ObliqueMap extends BaseOLMap {
 
   async gotoViewpoint(viewpoint: Viewpoint): Promise<void> {
     if (
-      this.movementDisabled ||
+      this.movementApiCallsDisabled ||
       !this.olMap ||
       !this._obliqueProvider ||
       !viewpoint.isValid()

package/src/map/openlayersMap.ts

@@ -106,7 +106,7 @@ class OpenlayersMap extends BaseOLMap {
   }
 
   gotoViewpoint(viewpoint: Viewpoint): Promise<void> {
-    if (this.movementDisabled || !viewpoint.isValid() || !this.olMap) {
+    if (this.movementApiCallsDisabled || !viewpoint.isValid() || !this.olMap) {
       return Promise.resolve();
     }
     let { heading } = viewpoint;

package/src/map/vcsMap.ts

@@ -1,9 +1,10 @@
+import { getLogger as getLoggerByName, Logger } from '@vcsuite/logger';
 import { v4 as uuidv4 } from 'uuid';
 import type { MapEvent as OLMapEvent } from 'ol';
 import type { Layer as OLLayer } from 'ol/layer.js';
 import type { Coordinate } from 'ol/coordinate.js';
 
-import { check, maybe, oneOf } from '@vcsuite/check';
+import { check, is, maybe, oneOf } from '@vcsuite/check';
 import VcsObject, { VcsObjectOptions } from '../vcsObject.js';
 import LayerCollection from '../util/layerCollection.js';
 import MapState from './mapState.js';
@@ -15,6 +16,11 @@ import { CesiumVisualisationType } from './cesiumMap.js';
 import type Viewpoint from '../util/viewpoint.js';
 import type Layer from '../layer/layer.js';
 import type { MapEvent } from '../interaction/abstractInteraction.js';
+import type { DisableMapControlOptions } from '../util/mapCollection.js';
+
+function getLogger(): Logger {
+  return getLoggerByName('vcMap');
+}
 
 export type VcsMapOptions = VcsObjectOptions & {
   /**
@@ -76,10 +82,11 @@ class VcsMap<
 
   initialized: boolean;
 
-  /**
-   * if true, no movements should occur
-   */
-  movementDisabled: boolean;
+  private _movementApiCallsDisabled = false;
+
+  private _movementKeyEventsDisabled = false;
+
+  private _movementPointerEventsDisabled = false;
 
   /**
    * The name of a map to fall back on, if this map cant show a viewpoint
@@ -134,8 +141,6 @@ class VcsMap<
 
     this.initialized = false;
 
-    this.movementDisabled = false;
-
     this.fallbackMap = options.fallbackMap || null;
 
     this._visualizations = new Map();
@@ -172,6 +177,44 @@ class VcsMap<
     return this._target;
   }
 
+  set movementDisabled(prevent: boolean) {
+    this._movementApiCallsDisabled = prevent;
+    this._movementKeyEventsDisabled = prevent;
+    this._movementPointerEventsDisabled = prevent;
+
+    getLogger().deprecate('movementDisabled', 'disableMovement');
+  }
+
+  /**
+   * @deprecated use disableMovement() for setting and movementApiCallsDisabled, movementKeyEventsDisabled and movementPointerEventsDisabled getter
+   */
+  get movementDisabled(): boolean {
+    getLogger().deprecate(
+      'movementDisabled',
+      'use the following getters: "movementApiCallsDisabled", "movementKeyEventsDisabled", "movementPointerEventsDisabled"',
+    );
+    return (
+      this._movementApiCallsDisabled &&
+      this._movementKeyEventsDisabled &&
+      this._movementPointerEventsDisabled
+    );
+  }
+
+  /** Whether api calls like gotoViewpoint & setting of oblique images are disabled */
+  get movementApiCallsDisabled(): boolean {
+    return this._movementApiCallsDisabled;
+  }
+
+  /** Whether movement related key events like the arrow keys for navigating in map are disabled. */
+  get movementKeyEventsDisabled(): boolean {
+    return this._movementKeyEventsDisabled;
+  }
+
+  /** Whether movement related pointer events for navigating in map are disabled. */
+  get movementPointerEventsDisabled(): boolean {
+    return this._movementPointerEventsDisabled;
+  }
+
   /**
    * The layer collection of this map. LayerCollections can be shared among maps.
    * When adding the map to a , the layer collection of the  will be set.
@@ -396,10 +439,20 @@ class VcsMap<
   }
 
   /**
-   * prevent all movement, including navigation controls, gotoViewpoint & setting of oblique images
+   * prevent all movement, including api calls (gotoViewpoint, setting oblique images), key and pointer events.
    */
-  disableMovement(prevent: boolean): void {
-    this.movementDisabled = prevent;
+  disableMovement(prevent: boolean | DisableMapControlOptions): void {
+    const disable: DisableMapControlOptions = is(prevent, Boolean)
+      ? {
+          apiCalls: prevent,
+          pointerEvents: prevent,
+          keyEvents: prevent,
+        }
+      : prevent;
+
+    this._movementApiCallsDisabled = disable.apiCalls;
+    this._movementKeyEventsDisabled = disable.keyEvents;
+    this._movementPointerEventsDisabled = disable.pointerEvents;
   }
 
   /**

package/src/util/clipping/clippingObject.ts

@@ -245,10 +245,19 @@ class ClippingObject {
   }
 
   handleMapChanged(map: VcsMap | null): void {
+    // clear old destroyed targets
+    this.targets.forEach((target, key) => {
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-ignore
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-call
+      if (target.isDestroyed && target.isDestroyed()) {
+        this.targets.delete(key);
+      }
+    });
     if (map instanceof CesiumMap) {
       const { globe } = map.getScene() as Scene;
       let raise = false;
-      if (this._terrain && !this.targets.has(globeSymbol)) {
+      if (this._terrain && !(this.targets.get(globeSymbol) === globe)) {
         this.targets.set(globeSymbol, globe);
         raise = true;
       } else if (!this._terrain && this.targets.has(globeSymbol)) {

package/src/util/clipping/clippingObjectManager.ts

@@ -233,6 +233,12 @@ class ClippingObjectManager {
 
     const setTargets = (clippingObject: ClippingObject): void => {
       clippingObject.targets.forEach((target) => {
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-call
+        if (target.isDestroyed && target.isDestroyed()) {
+          return;
+        }
         this._targetsMap.set(target, clippingObject);
         currentTargets.delete(target);
       });

package/src/util/clipping/clippingPlaneHelper.ts

@@ -266,6 +266,12 @@ export function copyClippingPlanesToCollection(
 export function clearClippingPlanes(
   target: Globe | Cesium3DTileset | Entity,
 ): void {
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  // @ts-ignore
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-call
+  if (target.isDestroyed && target.isDestroyed()) {
+    return;
+  }
   if (target instanceof Entity) {
     if (target.model) {
       if (target.model.clippingPlanes) {
@@ -399,11 +405,12 @@ export function setClippingPlanes(
 }
 
 /**
- * Creates a new feature at the given coordinate, which can be set on a .
+ * Creates a new feature at the given coordinate, which can then be used to create a clippingPlaneCollection.
  * @param  coordinate - in WGS84
  * @param  camera
  * @param  [vertical=false]
  * @param  [offsetDistance=25] - the offset from the coordinate to use for the size of the geometry
+ * @param  [rotate=0] - rotation of clipping plane in radians. 0 means vertical plane is parallel to camera.heading and horizontal feature is aligned with axes.
  * @returns  - the features geometry is in web mercator
  */
 export function createClippingFeature(
@@ -411,6 +418,7 @@ export function createClippingFeature(
   camera: Camera,
   vertical = false,
   offsetDistance = 25,
+  rotate = 0,
 ): Feature {
   check(coordinate, [Number]);
   check(vertical, Boolean);
@@ -418,18 +426,18 @@ export function createClippingFeature(
 
   let geometry;
   if (vertical) {
-    const p1 = offset(coordinate, -offsetDistance, camera.heading);
-    const p2 = offset(coordinate, offsetDistance, camera.heading);
+    const p1 = offset(coordinate, -offsetDistance, camera.heading + rotate);
+    const p2 = offset(coordinate, offsetDistance, camera.heading + rotate);
     geometry = new LineString(
       [
-        [p1[0], p1[1], coordinate[2]],
-        [p2[0], p2[1], coordinate[2]],
+        [p1[0], p1[1], coordinate[2] - offsetDistance],
+        [p2[0], p2[1], coordinate[2] - offsetDistance],
       ],
       'XYZ',
     );
   } else {
     geometry = new Polygon([[]], 'XYZ');
-    let bearing = 2 * Math.PI - Math.PI / 4; // Bearing NW
+    let bearing = 2 * Math.PI - Math.PI / 4 + rotate; // Bearing NW
     const coordinates = [...(new Array(4) as undefined[])].map(() => {
       const newPoint = offset(coordinate, offsetDistance, bearing);
       bearing -= Math.PI / 2;

package/src/util/editor/editFeaturesSession.ts

@@ -25,7 +25,7 @@ import MapInteractionController from './interactions/mapInteractionController.js
 import TranslateInteraction from './transformation/translateInteraction.js';
 import RotateInteraction from './transformation/rotateInteraction.js';
 import ScaleInteraction from './transformation/scaleInteraction.js';
-import { obliqueGeometry } from '../../layer/vectorSymbols.js';
+import { createSync, obliqueGeometry } from '../../layer/vectorSymbols.js';
 import ExtrudeInteraction from './transformation/extrudeInteraction.js';
 import ObliqueMap from '../../map/obliqueMap.js';
 import { ensureFeatureAbsolute, geometryChangeKeys } from './editorHelpers.js';
@@ -36,6 +36,7 @@ import { ModificationKeyType } from '../../interaction/interactionType.js';
 import type VcsApp from '../../vcsApp.js';
 import type VectorLayer from '../../layer/vectorLayer.js';
 import type VcsMap from '../../map/vcsMap.js';
+import RightClickInteraction from './interactions/rightClickInteraction.js';
 
 /**
  * Saves the original allowPicking settings and sets them to false if CTRL is not pressed.
@@ -77,6 +78,37 @@ function clearAllowPicking(
   }
 }
 
+/**
+ * Saves the original createSync State of the feature, and sets createSync to true.
+ * @param feature
+ * @param originalCreateSyncMap
+ */
+function setCreateSync(
+  feature: Feature,
+  originalCreateSyncMap: Map<string | number, boolean>,
+): void {
+  const id = feature.getId() as string | number;
+  const hasCreateSync = !!feature[createSync];
+  originalCreateSyncMap.set(id, hasCreateSync);
+  feature[createSync] = true;
+}
+
+/**
+ * Restores the original createSync State of the feature, and removes createSync if it was not set.
+ * @param feature
+ * @param originalCreateSyncMap
+ */
+function clearCreateSync(
+  feature: Feature,
+  originalCreateSyncMap: Map<string | number, boolean>,
+): void {
+  const id = feature.getId() as string | number;
+  if (!originalCreateSyncMap.get(id)) {
+    delete feature[createSync];
+  }
+  originalCreateSyncMap.delete(id);
+}
+
 export type EditFeaturesSession = EditorSession<SessionType.EDIT_FEATURES> & {
   readonly mode: TransformationMode;
   /**
@@ -127,6 +159,21 @@ function startEditFeaturesSession(
       });
     });
 
+  const rightClickStart = new RightClickInteraction();
+  rightClickStart.rightClicked.addEventListener(() => {
+    // we allow picking the Feature on rightClick, for this we add the RightClickInteraction
+    currentFeatures.forEach((feature) => {
+      feature.set('olcs_allowPicking', true);
+    });
+  });
+  rightClickStart.eventChainFinished.addEventListener(() => {
+    // reset olcs_allowPicking after rightClick
+    const allowPicking = modificationKey === ModificationKeyType.CTRL;
+    currentFeatures.forEach((feature) => {
+      feature.set('olcs_allowPicking', allowPicking);
+    });
+  });
+
   const scratchLayer = setupScratchLayer(app.layers);
 
   const {
@@ -135,6 +182,14 @@ function startEditFeaturesSession(
     destroy: destroyInteractionChain,
   } = setupInteractionChain(app.maps.eventHandler, interactionId);
 
+  const { exclusiveInteractionId } = app.maps.eventHandler;
+  const removeRightClickStart = app.maps.eventHandler.addExclusiveInteraction(
+    rightClickStart,
+    () => interactionRemoved.raiseEvent(),
+    0,
+    exclusiveInteractionId,
+  );
+
   const mouseOverInteraction = new EditFeaturesMouseOverInteraction();
   interactionChain.addInteraction(mouseOverInteraction);
 
@@ -308,6 +363,8 @@ function startEditFeaturesSession(
     );
   };
 
+  const originalCreateSyncMap = new Map<string | number, boolean>();
+
   const stop = (): void => {
     destroyTransformation();
     destroyInteractionChain();
@@ -315,12 +372,15 @@ function startEditFeaturesSession(
     mapChangedListener();
     modifierChangedListener();
     unByKey(featureListeners);
-    currentFeatures.forEach((feature) =>
-      clearAllowPicking(feature, allowPickingMap),
-    );
+    currentFeatures.forEach((feature) => {
+      clearAllowPicking(feature, allowPickingMap);
+      clearCreateSync(feature, originalCreateSyncMap);
+    });
     allowPickingMap.clear();
     app.layers.remove(scratchLayer);
     modeChanged.destroy();
+    removeRightClickStart();
+    rightClickStart.destroy();
     stopped.raiseEvent();
     stopped.destroy();
   };
@@ -340,14 +400,16 @@ function startEditFeaturesSession(
     translate,
     scale,
     setFeatures(features: Feature[]): void {
-      currentFeatures.forEach((feature) =>
-        clearAllowPicking(feature, allowPickingMap),
-      );
+      currentFeatures.forEach((feature) => {
+        clearAllowPicking(feature, allowPickingMap);
+        clearCreateSync(feature, originalCreateSyncMap);
+      });
       currentFeatures.length = 0;
       currentFeatures.push(...features);
-      currentFeatures.forEach((feature) =>
-        setAllowPicking(feature, allowPickingMap, modificationKey),
-      );
+      currentFeatures.forEach((feature) => {
+        setAllowPicking(feature, allowPickingMap, modificationKey);
+        setCreateSync(feature, originalCreateSyncMap);
+      });
       setFeatureListeners();
       transformationHandler?.setFeatures(features);
     },