@vcmap/core 5.0.0-rc.28 → 5.0.0-rc.29

package/src/interaction/eventHandler.js

@@ -7,7 +7,11 @@ import AbstractInteraction from './abstractInteraction.js';
 import InteractionChain from './interactionChain.js';
 import CoordinateAtPixel from './coordinateAtPixel.js';
 import FeatureAtPixelInteraction from './featureAtPixelInteraction.js';
-import { EventType, ModificationKeyType, PointerEventType } from './interactionType.js';
+import {
+  EventType,
+  ModificationKeyType,
+  PointerEventType,
+} from './interactionType.js';
 import FeatureProviderInteraction from './featureProviderInteraction.js';
 import VcsEvent from '../vcsEvent.js';
 
@@ -180,21 +184,27 @@ class EventHandler {
    * @readonly
    * @api
    */
-  get positionInteraction() { return this._positionInteraction; }
+  get positionInteraction() {
+    return this._positionInteraction;
+  }
 
   /**
    * @type {FeatureAtPixelInteraction}
    * @readonly
    * @api
    */
-  get featureInteraction() { return this._featureInteraction; }
+  get featureInteraction() {
+    return this._featureInteraction;
+  }
 
   /**
    * @api
    * @readonly
    * @type {FeatureProviderInteraction}
    */
-  get featureProviderInteraction() { return this._featureProviderInteraction; }
+  get featureProviderInteraction() {
+    return this._featureProviderInteraction;
+  }
 
   /**
    * A copy of all the EventHandler interactions
@@ -202,14 +212,18 @@ class EventHandler {
    * @type {AbstractInteraction[]}
    * @api
    */
-  get interactions() { return this._interactionChain.chain.slice(); }
+  get interactions() {
+    return this._interactionChain.chain.slice();
+  }
 
   /**
    * An event called, when the modifier changes. Order of precedence, if more then one key is pressed: SHIFT, ALT, CTRL
    * @type {VcsEvent<ModificationKeyType>}
    * @readonly
    */
-  get modifierChanged() { return this._modifierChanged; }
+  get modifierChanged() {
+    return this._modifierChanged;
+  }
 
   /**
    * Add a dynamic interaction to the interaction chain. This is the default methodology for
@@ -244,7 +258,11 @@ class EventHandler {
       };
     }
     this.exclusiveAdded.raiseEvent();
-    return this._exclusiveUnListen.bind(this, interaction, this._exclusiveInteraction.id);
+    return this._exclusiveUnListen.bind(
+      this,
+      interaction,
+      this._exclusiveInteraction.id,
+    );
   }
 
   /**
@@ -254,12 +272,12 @@ class EventHandler {
   removeExclusive() {
     if (this._exclusiveInteraction) {
       this._exclusiveInteraction.interactions
-        .filter(i => i)
+        .filter((i) => i)
         .forEach((i) => {
           this._interactionChain.removeInteraction(i);
         });
       this._exclusiveInteraction.cb
-        .filter(cb => cb)
+        .filter((cb) => cb)
         .forEach((cb) => {
           cb();
         });
@@ -276,17 +294,21 @@ class EventHandler {
    * @private
    */
   _exclusiveUnListen(interaction, id) {
-    if (!this._exclusiveInteraction || (this._exclusiveInteraction && this._exclusiveInteraction.id !== id)) {
+    if (
+      !this._exclusiveInteraction ||
+      (this._exclusiveInteraction && this._exclusiveInteraction.id !== id)
+    ) {
       return 0;
     }
     const removed = this._interactionChain.removeInteraction(interaction);
-    const index = this._exclusiveInteraction.interactions
-      .findIndex(candidate => candidate && candidate.id === interaction.id);
+    const index = this._exclusiveInteraction.interactions.findIndex(
+      (candidate) => candidate && candidate.id === interaction.id,
+    );
     if (index > -1) {
       this._exclusiveInteraction.interactions.splice(index, 1, undefined);
       this._exclusiveInteraction.cb.splice(index, 1, undefined);
     }
-    if (this._exclusiveInteraction.interactions.every(i => i === undefined)) {
+    if (this._exclusiveInteraction.interactions.every((i) => i === undefined)) {
       this._exclusiveInteraction = null;
     }
     if (removed > -1) {
@@ -308,7 +330,8 @@ class EventHandler {
     check(index, Number);
 
     this._interactionChain.addInteraction(interaction, index);
-    return () => (this._interactionChain.removeInteraction(interaction) !== -1 ? 1 : 0);
+    return () =>
+      this._interactionChain.removeInteraction(interaction) !== -1 ? 1 : 0;
   }
 
   /**
@@ -368,13 +391,19 @@ class EventHandler {
       if (
         this._lastClick.time &&
         Date.now() - this._lastClick.time < this.clickDuration &&
-        Cartesian2.distanceSquared(this._lastClick.windowPosition, actualEvent.windowPosition) < 12
+        Cartesian2.distanceSquared(
+          this._lastClick.windowPosition,
+          actualEvent.windowPosition,
+        ) < 12
       ) {
         this._lastClick.time = null;
         actualEvent.type = EventType.DBLCLICK;
       } else {
         this._lastClick.time = Date.now();
-        Cartesian2.clone(actualEvent.windowPosition, this._lastClick.windowPosition);
+        Cartesian2.clone(
+          actualEvent.windowPosition,
+          this._lastClick.windowPosition,
+        );
         actualEvent.type = EventType.CLICK;
       }
       this._startChain(actualEvent);
@@ -395,7 +424,10 @@ class EventHandler {
         actualEvent.key = this._dragging.key;
         actualEvent.pointer = this._dragging.pointer;
         this._startChain(actualEvent, true);
-      } else if (!this._dragging && Date.now() - this._lastDown.time > this.dragDuration) {
+      } else if (
+        !this._dragging &&
+        Date.now() - this._lastDown.time > this.dragDuration
+      ) {
         actualEvent = { type: EventType.DRAGSTART, ...this._lastDown };
         this._dragging = actualEvent;
         this._startChain(actualEvent, true);
@@ -417,15 +449,23 @@ class EventHandler {
     }
 
     if (
-      this._lastKeyEventModifiers.get(ModificationKeyType.SHIFT) !== event.shiftKey ||
-      this._lastKeyEventModifiers.get(ModificationKeyType.ALT) !== event.altKey ||
-      this._lastKeyEventModifiers.get(ModificationKeyType.CTRL) !== event.ctrlKey
+      this._lastKeyEventModifiers.get(ModificationKeyType.SHIFT) !==
+        event.shiftKey ||
+      this._lastKeyEventModifiers.get(ModificationKeyType.ALT) !==
+        event.altKey ||
+      this._lastKeyEventModifiers.get(ModificationKeyType.CTRL) !==
+        event.ctrlKey
     ) {
-      this._lastKeyEventModifiers.set(ModificationKeyType.SHIFT, event.shiftKey);
+      this._lastKeyEventModifiers.set(
+        ModificationKeyType.SHIFT,
+        event.shiftKey,
+      );
       this._lastKeyEventModifiers.set(ModificationKeyType.ALT, event.altKey);
       this._lastKeyEventModifiers.set(ModificationKeyType.CTRL, event.ctrlKey);
-      const modifier = [...this._lastKeyEventModifiers.keys()]
-        .find(k => this._lastKeyEventModifiers.get(k)) || ModificationKeyType.NONE;
+      const modifier =
+        [...this._lastKeyEventModifiers.keys()].find((k) =>
+          this._lastKeyEventModifiers.get(k),
+        ) || ModificationKeyType.NONE;
 
       if (modifier !== this._lastDispatchedModifier) {
         this._interactionChain.modifierChanged(modifier);

package/src/interaction/featureAtPixelInteraction.js

@@ -9,7 +9,11 @@ import {
 
 import AbstractInteraction from './abstractInteraction.js';
 import Projection from '../util/projection.js';
-import { EventType, ModificationKeyType, PointerKeyType } from './interactionType.js';
+import {
+  EventType,
+  ModificationKeyType,
+  PointerKeyType,
+} from './interactionType.js';
 import { vcsLayerName } from '../layer/layerSymbols.js';
 import { originalFeatureSymbol } from '../layer/vectorSymbols.js';
 
@@ -19,7 +23,11 @@ import { originalFeatureSymbol } from '../layer/vectorSymbols.js';
  */
 class FeatureAtPixelInteraction extends AbstractInteraction {
   constructor() {
-    super(EventType.ALL ^ EventType.MOVE, ModificationKeyType.ALL, PointerKeyType.ALL);
+    super(
+      EventType.ALL ^ EventType.MOVE,
+      ModificationKeyType.ALL,
+      PointerKeyType.ALL,
+    );
     /**
      * @type {EventType|number}
      * @private
@@ -67,7 +75,9 @@ class FeatureAtPixelInteraction extends AbstractInteraction {
    * @type {number}
    * @api
    */
-  get pickPosition() { return this._pickPosition; }
+  get pickPosition() {
+    return this._pickPosition;
+  }
 
   /**
    * @param {number} position
@@ -81,7 +91,9 @@ class FeatureAtPixelInteraction extends AbstractInteraction {
    * @type {number}
    * @api
    */
-  get excludedPickPositionEvents() { return ~this._pickPositionMask; }
+  get excludedPickPositionEvents() {
+    return ~this._pickPositionMask;
+  }
 
   /**
    * @param {number} position
@@ -146,14 +158,26 @@ class FeatureAtPixelInteraction extends AbstractInteraction {
     let found = null;
     /** @type {null|import("ol/layer/Layer").default} */
     let foundLayer = null;
-    /** @type {import("@vcmap/core").OpenlayersMap} */ (event.map).olMap
-      .forEachFeatureAtPixel([event.windowPosition.x, event.windowPosition.y], (feat, layer) => {
-        if (feat && (feat.get('olcs_allowPicking') == null || feat.get('olcs_allowPicking') === true)) {
-          found = /** @type {import("ol").Feature<import("ol/geom/Geometry").default>} */ (feat);
+    /** @type {import("@vcmap/core").OpenlayersMap} */ (
+      event.map
+    ).olMap.forEachFeatureAtPixel(
+      [event.windowPosition.x, event.windowPosition.y],
+      (feat, layer) => {
+        if (
+          feat &&
+          (feat.get('olcs_allowPicking') == null ||
+            feat.get('olcs_allowPicking') === true)
+        ) {
+          found =
+            /** @type {import("ol").Feature<import("ol/geom/Geometry").default>} */ (
+              feat
+            );
           foundLayer = layer;
         }
         return true;
-      }, { hitTolerance: this.hitTolerance });
+      },
+      { hitTolerance: this.hitTolerance },
+    );
     if (found && foundLayer) {
       event.feature = found;
       if (found.get('features')) {
@@ -174,14 +198,19 @@ class FeatureAtPixelInteraction extends AbstractInteraction {
     let found = null;
     /** @type {null|import("ol/layer/Layer").default} */
     let foundLayer = null;
-    /** @type {import("@vcmap/core").ObliqueMap} */ (event.map).olMap
-      .forEachFeatureAtPixel([event.windowPosition.x, event.windowPosition.y], (feat, layer) => {
+    /** @type {import("@vcmap/core").ObliqueMap} */ (
+      event.map
+    ).olMap.forEachFeatureAtPixel(
+      [event.windowPosition.x, event.windowPosition.y],
+      (feat, layer) => {
         if (feat) {
           found = feat[originalFeatureSymbol] || feat;
         }
         foundLayer = layer;
         return true;
-      }, { hitTolerance: this.hitTolerance });
+      },
+      { hitTolerance: this.hitTolerance },
+    );
 
     if (found && foundLayer) {
       event.feature = found;
@@ -199,10 +228,16 @@ class FeatureAtPixelInteraction extends AbstractInteraction {
    * @private
    */
   _cesiumHandler(event) {
-    const cesiumMap = /** @type {import("@vcmap/core").CesiumMap} */ (event.map);
+    const cesiumMap = /** @type {import("@vcmap/core").CesiumMap} */ (
+      event.map
+    );
     const scene = cesiumMap.getScene();
 
-    const object = scene.pick(event.windowPosition, this.hitTolerance, this.hitTolerance);
+    const object = scene.pick(
+      event.windowPosition,
+      this.hitTolerance,
+      this.hitTolerance,
+    );
 
     let scratchCartographic = new Cartographic();
     let scratchCartesian = new Cartesian3();
@@ -215,40 +250,62 @@ class FeatureAtPixelInteraction extends AbstractInteraction {
         return Promise.resolve(event);
       }
       if (this.pullPickedPosition && event.ray) {
-        scratchPullCartesian = Cartesian3
-          .multiplyByScalar(event.ray.direction, this.pullPickedPosition, scratchPullCartesian);
+        scratchPullCartesian = Cartesian3.multiplyByScalar(
+          event.ray.direction,
+          this.pullPickedPosition,
+          scratchPullCartesian,
+        );
 
-        scratchCartesian = Cartesian3.subtract(scratchCartesian, scratchPullCartesian, scratchCartesian);
+        scratchCartesian = Cartesian3.subtract(
+          scratchCartesian,
+          scratchPullCartesian,
+          scratchCartesian,
+        );
       }
-      scratchCartographic = Cartographic
-        .fromCartesian(scratchCartesian, scene.globe.ellipsoid, scratchCartographic);
-      event.position = Projection.wgs84ToMercator([
-        CesiumMath.toDegrees(scratchCartographic.longitude),
-        CesiumMath.toDegrees(scratchCartographic.latitude),
-        scratchCartographic.height,
-      ], true);
+      scratchCartographic = Cartographic.fromCartesian(
+        scratchCartesian,
+        scene.globe.ellipsoid,
+        scratchCartographic,
+      );
+      event.position = Projection.wgs84ToMercator(
+        [
+          CesiumMath.toDegrees(scratchCartographic.longitude),
+          CesiumMath.toDegrees(scratchCartographic.latitude),
+          scratchCartographic.height,
+        ],
+        true,
+      );
       event.positionOrPixel = event.position;
       scene.pickTranslucentDepth = pickTranslucentDepth;
       return Promise.resolve(event);
     };
 
     if (object) {
-      if (object.primitive && object.primitive.olFeature) { // vector & vectorCluster
+      if (object.primitive && object.primitive.olFeature) {
+        // vector & vectorCluster
         event.feature = object.primitive.olFeature;
       } else if (
         object.primitive &&
         object.primitive[vcsLayerName] &&
-        (object instanceof Cesium3DTileFeature || object instanceof Cesium3DTilePointFeature)
-      ) { // building
+        (object instanceof Cesium3DTileFeature ||
+          object instanceof Cesium3DTilePointFeature)
+      ) {
+        // building
         event.feature = object;
         const symbols = Object.getOwnPropertySymbols(object.primitive);
         const symbolLength = symbols.length;
         for (let i = 0; i < symbolLength; i++) {
           event.feature[symbols[i]] = object.primitive[symbols[i]];
         }
-      } else if (object.id && object.id.olFeature) { // cluster size === 1
+      } else if (object.id && object.id.olFeature) {
+        // cluster size === 1
         event.feature = object.id.olFeature;
-      } else if (object.id && object.id[vcsLayerName] && object.id instanceof Entity) { // entity
+      } else if (
+        object.id &&
+        object.id[vcsLayerName] &&
+        object.id instanceof Entity
+      ) {
+        // entity
         event.feature = object.id;
       }
 
@@ -260,13 +317,20 @@ class FeatureAtPixelInteraction extends AbstractInteraction {
         if (
           object.primitive &&
           this.pickTranslucent &&
-          !(object.primitive.pointCloudShading && object.primitive.pointCloudShading.attenuation)
-        ) { // XXX should this always be on, also for non vector?
+          !(
+            object.primitive.pointCloudShading &&
+            object.primitive.pointCloudShading.attenuation
+          )
+        ) {
+          // XXX should this always be on, also for non vector?
           scene.pickTranslucentDepth = true;
           scene.render(cesiumMap.getCesiumWidget().clock.currentTime);
           event.exactPosition = true;
         }
-        scratchCartesian = scene.pickPosition(event.windowPosition, scratchCartesian);
+        scratchCartesian = scene.pickPosition(
+          event.windowPosition,
+          scratchCartesian,
+        );
         return handlePick();
       }
     }

package/src/interaction/featureProviderInteraction.js

@@ -1,5 +1,9 @@
 import AbstractInteraction from './abstractInteraction.js';
-import { EventType, ModificationKeyType, PointerKeyType } from './interactionType.js';
+import {
+  EventType,
+  ModificationKeyType,
+  PointerKeyType,
+} from './interactionType.js';
 
 /**
  * @class
@@ -20,16 +24,27 @@ class FeatureProviderInteraction extends AbstractInteraction {
   // eslint-disable-next-line class-methods-use-this
   async pipe(event) {
     if (!event.feature) {
-      const layersWithProvider = [...event.map.layerCollection]
-        .filter((l) => {
-          return l.featureProvider && l.active && l.isSupported(event.map) && l.featureProvider.isSupported(event.map);
-        });
+      const layersWithProvider = [...event.map.layerCollection].filter((l) => {
+        return (
+          l.featureProvider &&
+          l.active &&
+          l.isSupported(event.map) &&
+          l.featureProvider.isSupported(event.map)
+        );
+      });
 
       if (layersWithProvider.length > 0) {
         const resolution = event.map.getCurrentResolution(event.position);
-        const features = (await Promise
-          .all(layersWithProvider.map(l => l.featureProvider.getFeaturesByCoordinate(event.position, resolution))))
-          .flat();
+        const features = (
+          await Promise.all(
+            layersWithProvider.map((l) =>
+              l.featureProvider.getFeaturesByCoordinate(
+                event.position,
+                resolution,
+              ),
+            ),
+          )
+        ).flat();
 
         if (features.length > 0) {
           event.feature = features[0];

package/src/interaction/interactionChain.js

@@ -1,5 +1,9 @@
 import AbstractInteraction from './abstractInteraction.js';
-import { EventType, ModificationKeyType, PointerKeyType } from './interactionType.js';
+import {
+  EventType,
+  ModificationKeyType,
+  PointerKeyType,
+} from './interactionType.js';
 
 /**
  * @class
@@ -41,7 +45,9 @@ class InteractionChain extends AbstractInteraction {
    * @api
    */
   removeInteraction(interaction) {
-    const index = this.chain.findIndex(candidate => candidate.id === interaction.id);
+    const index = this.chain.findIndex(
+      (candidate) => candidate.id === interaction.id,
+    );
     if (index > -1) {
       this.chain.splice(index, 1);
     }
@@ -60,9 +66,9 @@ class InteractionChain extends AbstractInteraction {
     for (let i = 0; i < chainLength; i++) {
       const interaction = chain[i];
       if (
-        (interaction.active & event.type) &&
-        (interaction.modificationKey & event.key) &&
-        (interaction.pointerKey & event.pointer)
+        interaction.active & event.type &&
+        interaction.modificationKey & event.key &&
+        interaction.pointerKey & event.pointer
       ) {
         // eslint-disable-next-line no-await-in-loop
         pipedEvent = await interaction.pipe(pipedEvent);
@@ -79,8 +85,11 @@ class InteractionChain extends AbstractInteraction {
    * @param {ModificationKeyType} modifier
    */
   modifierChanged(modifier) {
-    this.chain.filter(i => i.active !== EventType.NONE)
-      .forEach((i) => { i.modifierChanged(modifier); });
+    this.chain
+      .filter((i) => i.active !== EventType.NONE)
+      .forEach((i) => {
+        i.modifierChanged(modifier);
+      });
   }
 
   /**
@@ -103,11 +112,12 @@ class InteractionChain extends AbstractInteraction {
    * @inheritDoc
    */
   destroy() {
-    this.chain.forEach((i) => { i.destroy(); });
+    this.chain.forEach((i) => {
+      i.destroy();
+    });
     this.chain = [];
     super.destroy();
   }
 }
 
 export default InteractionChain;
-

package/src/interaction/interactionType.js

@@ -8,7 +8,9 @@ export class BitCounter {
   /**
    * @returns {number}
    */
-  static get interactionTypeCounter() { return nextBit; }
+  static get interactionTypeCounter() {
+    return nextBit;
+  }
 
   static getNextBit(counter) {
     return counter << 1;
@@ -26,14 +28,15 @@ export class BitCounter {
  * @api
  */
 export const ModificationKeyType = {
-  NONE: nextBit = BitCounter.getNextBit(nextBit),
-  ALT: nextBit = BitCounter.getNextBit(nextBit),
-  CTRL: nextBit = BitCounter.getNextBit(nextBit),
-  SHIFT: nextBit = BitCounter.getNextBit(nextBit),
+  NONE: (nextBit = BitCounter.getNextBit(nextBit)),
+  ALT: (nextBit = BitCounter.getNextBit(nextBit)),
+  CTRL: (nextBit = BitCounter.getNextBit(nextBit)),
+  SHIFT: (nextBit = BitCounter.getNextBit(nextBit)),
   ALL: 0,
 };
 
-ModificationKeyType.ALL = ModificationKeyType.NONE |
+ModificationKeyType.ALL =
+  ModificationKeyType.NONE |
   ModificationKeyType.ALT |
   ModificationKeyType.CTRL |
   ModificationKeyType.SHIFT;
@@ -55,25 +58,21 @@ ModificationKeyType.ALL = ModificationKeyType.NONE |
  */
 export const EventType = {
   NONE: 0,
-  CLICK: nextBit = BitCounter.getNextBit(nextBit),
-  DBLCLICK: nextBit = BitCounter.getNextBit(nextBit),
-  DRAG: nextBit = BitCounter.getNextBit(nextBit),
-  DRAGSTART: nextBit = BitCounter.getNextBit(nextBit),
-  DRAGEND: nextBit = BitCounter.getNextBit(nextBit),
-  MOVE: nextBit = BitCounter.getNextBit(nextBit),
+  CLICK: (nextBit = BitCounter.getNextBit(nextBit)),
+  DBLCLICK: (nextBit = BitCounter.getNextBit(nextBit)),
+  DRAG: (nextBit = BitCounter.getNextBit(nextBit)),
+  DRAGSTART: (nextBit = BitCounter.getNextBit(nextBit)),
+  DRAGEND: (nextBit = BitCounter.getNextBit(nextBit)),
+  MOVE: (nextBit = BitCounter.getNextBit(nextBit)),
   DRAGEVENTS: 0,
   CLICKMOVE: 0,
   ALL: 0,
 };
-EventType.DRAGEVENTS = EventType.DRAG |
-  EventType.DRAGEND |
-  EventType.DRAGSTART;
+EventType.DRAGEVENTS = EventType.DRAG | EventType.DRAGEND | EventType.DRAGSTART;
 
-EventType.CLICKMOVE = EventType.CLICK |
-  EventType.MOVE;
+EventType.CLICKMOVE = EventType.CLICK | EventType.MOVE;
 
-EventType.ALL = Object.values(EventType)
-  .reduce((val, mask) => val | mask, 0);
+EventType.ALL = Object.values(EventType).reduce((val, mask) => val | mask, 0);
 
 /**
  * Enumeration of pointer keys.
@@ -85,15 +84,14 @@ EventType.ALL = Object.values(EventType)
  * @api
  */
 export const PointerKeyType = {
-  LEFT: nextBit = BitCounter.getNextBit(nextBit),
-  RIGHT: nextBit = BitCounter.getNextBit(nextBit),
-  MIDDLE: nextBit = BitCounter.getNextBit(nextBit),
+  LEFT: (nextBit = BitCounter.getNextBit(nextBit)),
+  RIGHT: (nextBit = BitCounter.getNextBit(nextBit)),
+  MIDDLE: (nextBit = BitCounter.getNextBit(nextBit)),
   ALL: 0,
 };
 
-PointerKeyType.ALL = PointerKeyType.LEFT |
-  PointerKeyType.RIGHT |
-  PointerKeyType.MIDDLE;
+PointerKeyType.ALL =
+  PointerKeyType.LEFT | PointerKeyType.RIGHT | PointerKeyType.MIDDLE;
 
 /**
  * Enumeration of pointer key events.
@@ -107,4 +105,3 @@ export const PointerEventType = {
   UP: 2,
   MOVE: 3,
 };
-