@vcmap/core 5.0.0-rc.8 → 5.0.0

package/src/interaction/eventHandler.js

@@ -1,425 +0,0 @@
-import { v4 as uuidv4 } from 'uuid';
-import { Cartesian2 } from '@vcmap/cesium';
-
-import { check, checkMaybe } from '@vcsuite/check';
-import { getLogger as getLoggerByName } from '@vcsuite/logger';
-import AbstractInteraction from './abstractInteraction.js';
-import InteractionChain from './interactionChain.js';
-import CoordinateAtPixel from './coordinateAtPixel.js';
-import FeatureAtPixelInteraction from './featureAtPixelInteraction.js';
-import { EventType, PointerEventType } from './interactionType.js';
-import FeatureProviderInteraction from './featureProviderInteraction.js';
-import VcsEvent from '../vcsEvent.js';
-
-/**
- * @namespace interaction
- * @api
- */
-
-/**
- * @typedef {Object} EventHandlerExclusiveInteraction
- * @property {string} id
- * @property {Array<AbstractInteraction>} interactions
- * @property {Array<Function>} cb
- */
-
-/**
- * @typedef {Object} MapEvent
- * @property {PointerEventType} pointerEvent
- * @property {import("@vcmap/core").VcsMap} map
- * @property {import("@vcmap/cesium").Cartesian2} windowPosition
- * @property {import("@vcmap/core").ModificationKeyType} key
- * @property {import("@vcmap/core").PointerKeyType} pointer
- * @property {import("ol/coordinate").Coordinate|undefined} position - position in web mercator coordinates
- * @property {import("ol/coordinate").Coordinate|undefined} positionOrPixel - position in web mercator coordinates or image coordinates in ObliqueMap Map Mode
- * @property {boolean|undefined} multipleTouch - vcs:undocumented
- * @property {number|null|undefined} time - vcs:undocumented
- */
-
-/**
- * @typedef {Object} LastClick
- * @property {import("@vcmap/cesium").Cartesian2} windowPosition - vcs:undocumented
- * @property {number|null} time - vcs:undocumented
- * @api
- */
-
-/**
- * @returns {import("@vcsuite/logger").Logger}
- */
-function getLogger() {
-  return getLoggerByName('EventHandler');
-}
-
-/**
- * @class
- */
-class EventHandler {
-  constructor() {
-    /**
-     * @type {CoordinateAtPixel}
-     * @private
-     */
-    this._positionInteraction = new CoordinateAtPixel();
-    /**
-     * @type {FeatureAtPixelInteraction}
-     * @private
-     */
-    this._featureInteraction = new FeatureAtPixelInteraction();
-    /**
-     * @type {FeatureProviderInteraction}
-     * @private
-     */
-    this._featureProviderInteraction = new FeatureProviderInteraction();
-    /**
-     * @type {InteractionChain}
-     * @private
-     */
-    this._interactionChain = new InteractionChain([
-      this._positionInteraction,
-      this._featureInteraction,
-      this._featureProviderInteraction,
-    ]);
-
-    /**
-     * @type {number}
-     */
-    this.clickDuration = 400;
-
-    /**
-     * @type {number}
-     */
-    this.dragDuration = 100;
-
-    /**
-     * @type {null|MapEvent}
-     * @private
-     */
-    this._lastDown = null;
-
-    /**
-     * @type {LastClick}
-     * @private
-     */
-    this._lastClick = {
-      time: null,
-      windowPosition: new Cartesian2(),
-    };
-
-    /**
-     * @type {null|MapEvent}
-     * @private
-     */
-    this._dragging = null;
-
-    /**
-     * @type {boolean}
-     * @private
-     */
-    this._running = false;
-
-    /**
-     * @type {Array<InteractionEvent>}
-     * @private
-     */
-    this._eventQueue = [];
-
-    /**
-     * @type {EventHandlerExclusiveInteraction|null}
-     * @private
-     */
-    this._exclusiveInteraction = null;
-
-    /**
-     * @type {boolean}
-     * @private
-     */
-    this._multiples = false;
-    /**
-     * Event called, when exclusive events are removed
-     * @type {VcsEvent<void>}
-     * @api
-     */
-    this.exclusiveRemoved = new VcsEvent();
-    /**
-     * Event called, when exclusive events are added
-     * @type {VcsEvent<void>}
-     * @api
-     */
-    this.exclusiveAdded = new VcsEvent();
-  }
-
-  /**
-   * @type {CoordinateAtPixel}
-   * @readonly
-   * @api
-   */
-  get positionInteraction() { return this._positionInteraction; }
-
-  /**
-   * @type {FeatureAtPixelInteraction}
-   * @readonly
-   * @api
-   */
-  get featureInteraction() { return this._featureInteraction; }
-
-  /**
-   * @api
-   * @readonly
-   * @type {FeatureProviderInteraction}
-   */
-  get featureProviderInteraction() { return this._featureProviderInteraction; }
-
-  /**
-   * A copy of all the EventHandler interactions
-   * @readonly
-   * @type {AbstractInteraction[]}
-   * @api
-   */
-  get interactions() { return this._interactionChain.chain.slice(); }
-
-  /**
-   * 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,
-   * this interaction is removed and a provided callback is called. Use the id parameter to add multiple interactions
-   * from the same source (if you don't wish to provide an {@link InteractionChain}
-   * @param {AbstractInteraction} interaction
-   * @param {Function} removed - the callback for when the interaction is forcefully removed.
-   * @param {number=} [index=3] - the position at which to push the interaction
-   * @param {string=} id - an id to allow for multiple interactions to belong to the same exclusive registerer
-   * @returns {Function} function to remove the interaction with. returns number of removed interactions (0|1)
-   * @api
-   */
-  addExclusiveInteraction(interaction, removed, index = 3, id) {
-    check(interaction, AbstractInteraction);
-    check(removed, Function);
-    check(index, Number);
-    checkMaybe(id, String);
-
-    if (this._exclusiveInteraction && this._exclusiveInteraction.id !== id) {
-      this.removeExclusive();
-    }
-    this._interactionChain.addInteraction(interaction, index);
-    if (this._exclusiveInteraction) {
-      this._exclusiveInteraction.interactions.push(interaction);
-      this._exclusiveInteraction.cb.push(removed);
-    } else {
-      this._exclusiveInteraction = {
-        id: id || uuidv4(),
-        cb: [removed],
-        interactions: [interaction],
-      };
-    }
-    this.exclusiveAdded.raiseEvent();
-    return this._exclusiveUnListen.bind(this, interaction, this._exclusiveInteraction.id);
-  }
-
-  /**
-   * Removes any exclusive listeners. Typically only called from the framework to ensure the pubsub listeners are consistent
-   * @api
-   */
-  removeExclusive() {
-    if (this._exclusiveInteraction) {
-      this._exclusiveInteraction.interactions
-        .filter(i => i)
-        .forEach((i) => {
-          this._interactionChain.removeInteraction(i);
-        });
-      this._exclusiveInteraction.cb
-        .filter(cb => cb)
-        .forEach((cb) => {
-          cb();
-        });
-      this._exclusiveInteraction = null;
-      this.exclusiveRemoved.raiseEvent();
-    }
-  }
-
-  /**
-   * Removes an exclusive interaction by its id
-   * @param {AbstractInteraction} interaction
-   * @param {string} id
-   * @returns {number}
-   * @private
-   */
-  _exclusiveUnListen(interaction, 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);
-    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)) {
-      this._exclusiveInteraction = null;
-    }
-    if (removed > -1) {
-      this.exclusiveRemoved.raiseEvent();
-    }
-    return removed !== -1 ? 1 : 0;
-  }
-
-  /**
-   * Adds an interaction permanently to the interaction chain. Only add non-interferring
-   * interactions in such a fashion (for instance for displaying the cursor position)
-   * @param {AbstractInteraction} interaction
-   * @param {number=} [index=3] - at what position this interaction should be added. By default, it is added after the featureProviderInteraction
-   * @returns {function():number} function to remove the interaction with. returns number of removed interactions (0|1)
-   * @api
-   */
-  addPersistentInteraction(interaction, index = 3) {
-    check(interaction, AbstractInteraction);
-    check(index, Number);
-
-    this._interactionChain.addInteraction(interaction, index);
-    return () => (this._interactionChain.removeInteraction(interaction) !== -1 ? 1 : 0);
-  }
-
-  /**
-   * Handles an event triggered by {@link import("@vcmap/core").VcsMap.pointerInteractionEvent}
-   * @param {MapEvent} event
-   * @api
-   */
-  handleMapEvent(event) {
-    if (event.pointerEvent === PointerEventType.MOVE) {
-      this._mouseMove(event);
-    } else if (event.pointerEvent === PointerEventType.DOWN) {
-      this._mouseDown(event);
-    } else if (event.pointerEvent === PointerEventType.UP) {
-      this._mouseUp(event);
-    }
-  }
-
-  /**
-   * @param {MapEvent} event
-   * @private
-   */
-  _mouseDown(event) {
-    if (this._lastDown) {
-      this._multiples = true;
-      return;
-    }
-    if (event.windowPosition.x === 0 && event.windowPosition.y === 0) {
-      return;
-    }
-    this._lastDown = event;
-    this._lastDown.time = Date.now();
-  }
-
-  /**
-   * @param {MapEvent} event
-   * @private
-   */
-  _mouseUp(event) {
-    if (event.multipleTouch) {
-      this._multiples = true;
-      this._lastDown = null;
-      return;
-    }
-    if (this._multiples) {
-      this._lastDown = null;
-      this._multiples = false;
-      return;
-    }
-
-    const actualEvent = /** @type {InteractionEvent} */ (event);
-    if (this._dragging) {
-      actualEvent.type = EventType.DRAGEND;
-      actualEvent.key = this._dragging.key;
-      actualEvent.pointer = this._dragging.pointer;
-      this._startChain(actualEvent);
-    } else if (this._lastDown) {
-      if (
-        this._lastClick.time &&
-        Date.now() - this._lastClick.time < this.clickDuration &&
-        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);
-        actualEvent.type = EventType.CLICK;
-      }
-      this._startChain(actualEvent);
-    }
-    this._dragging = null;
-    this._lastDown = null;
-  }
-
-  /**
-   * @param {MapEvent} event
-   * @private
-   */
-  _mouseMove(event) {
-    let actualEvent = /** @type {InteractionEvent} */ (event);
-    if (this._lastDown) {
-      if (this._dragging) {
-        actualEvent.type = EventType.DRAG;
-        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) {
-        actualEvent = { type: EventType.DRAGSTART, ...this._lastDown };
-        this._dragging = actualEvent;
-        this._startChain(actualEvent, true);
-      }
-    } else {
-      actualEvent.type = EventType.MOVE;
-      this._startChain(actualEvent, true);
-    }
-  }
-
-  /**
-   * @param {InteractionEvent} event
-   * @param {boolean=} discardOnRunning if true the event will discarded if an eventHandler is already Running
-   * @private
-   */
-  _startChain(event, discardOnRunning) {
-    if (this._running && discardOnRunning) {
-      return;
-    }
-    if (this._running) {
-      this._eventQueue.push(event);
-    } else {
-      this._running = true;
-      this._interactionChain
-        .pipe(event)
-        .then(this._endChain.bind(this))
-        .catch((error) => {
-          getLogger().error(error.message);
-          this._endChain();
-        });
-    }
-  }
-
-  /**
-   * @private
-   */
-  _endChain() {
-    this._running = false;
-    if (this._eventQueue.length > 0) {
-      this._startChain(this._eventQueue.shift());
-    }
-  }
-
-  /**
-   * Destroys the event handler and its interaction chain.
-   */
-  destroy() {
-    this.removeExclusive();
-    this.exclusiveAdded.destroy();
-    this.exclusiveRemoved.destroy();
-    this._interactionChain.destroy();
-    this._interactionChain = null;
-    this._positionInteraction.destroy();
-    this._positionInteraction = null;
-    this._featureInteraction.destroy();
-    this._featureInteraction = null;
-    this._eventQueue = [];
-  }
-}
-
-export default EventHandler;

package/src/interaction/featureAtPixelInteraction.js

@@ -1,273 +0,0 @@
-import { Cartographic, Cartesian3, Math as CesiumMath, Cesium3DTileFeature, Cesium3DTilePointFeature } from '@vcmap/cesium';
-
-import AbstractInteraction from './abstractInteraction.js';
-import Projection from '../util/projection.js';
-import { EventType, ModificationKeyType } from './interactionType.js';
-import { vcsLayerName } from '../layer/layerSymbols.js';
-import { originalFeatureSymbol } from '../layer/vectorSymbols.js';
-
-/**
- * @class
- * @extends {AbstractInteraction}
- */
-class FeatureAtPixelInteraction extends AbstractInteraction {
-  constructor() {
-    super(EventType.ALL ^ EventType.MOVE, ModificationKeyType.ALL);
-    /**
-     * @type {EventType|number}
-     * @private
-     */
-    this._pickPosition = EventType.CLICK;
-    /**
-     * @type {number}
-     * @private
-     */
-    this._pickPositionMask = -1;
-
-    /**
-     * whether to pick translucent depth or not, defaults to true
-     * @type {boolean}
-     * @api
-     */
-    this.pickTranslucent = true;
-
-    /**
-     * <i>Pulls</i> the picked position towards the camera position by this number
-     * @type {number}
-     * @default 0
-     * @api
-     */
-    this.pullPickedPosition = 0;
-
-    /**
-     * The number of pixels to take into account for picking features
-     * @type {number}
-     * @default 10
-     * @api
-     */
-    this.hitTolerance = 10;
-
-    /**
-     * @type {import("ol").Feature<import("ol/geom/Geometry").default>|Object|null}
-     * @private
-     */
-    this._draggingFeature = null;
-    this.setActive();
-  }
-
-  /**
-   * Bitmask of {@link EventType} for which events to pick the position
-   * @type {number}
-   * @api
-   */
-  get pickPosition() { return this._pickPosition; }
-
-  /**
-   * @param {number} position
-   */
-  set pickPosition(position) {
-    this._pickPosition = position & this._pickPositionMask;
-  }
-
-  /**
-   * Bitmask of {@link EventType} for which to never pick positions.
-   * @type {number}
-   * @api
-   */
-  get excludedPickPositionEvents() { return ~this._pickPositionMask; }
-
-  /**
-   * @param {number} position
-   */
-  set excludedPickPositionEvents(position) {
-    this._pickPositionMask = ~position;
-  }
-
-  /**
-   * @inheritDoc
-   * @param {InteractionEvent} event
-   * @returns {Promise<InteractionEvent>}
-   */
-  async pipe(event) {
-    if (event.type & EventType.DRAG && !(this._pickPosition & EventType.DRAG)) {
-      if (this._draggingFeature) {
-        event.feature = this._draggingFeature;
-      }
-      return event;
-    }
-
-    if (event.type & EventType.DRAGEND) {
-      this._draggingFeature = null;
-    }
-
-    if (event.map.className === 'OpenlayersMap') {
-      await this._openlayersHandler(event);
-    } else if (event.map.className === 'ObliqueMap') {
-      await this._obliqueHandler(event);
-    } else if (event.map.className === 'CesiumMap') {
-      await this._cesiumHandler(event);
-    }
-    if (event.type & EventType.DRAGSTART && event.feature) {
-      this._draggingFeature = event.feature;
-    }
-
-    if (event.type & EventType.DRAG && this._draggingFeature) {
-      event.feature = this._draggingFeature;
-    }
-    return event;
-  }
-
-  /**
-   * @inheritDoc
-   * @param {(boolean|number)=} active
-   */
-  setActive(active) {
-    if (typeof active === 'undefined') {
-      this.pickPosition = EventType.CLICK;
-      this.pullPickedPosition = 0;
-    }
-    super.setActive(active);
-  }
-
-  /**
-   * @param {InteractionEvent} event
-   * @returns {Promise<InteractionEvent>}
-   * @private
-   */
-  _openlayersHandler(event) {
-    /** @type {null|import("ol").Feature<import("ol/geom/Geometry").default>} */
-    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);
-          foundLayer = layer;
-        }
-        return true;
-      }, { hitTolerance: this.hitTolerance });
-    if (found && foundLayer) {
-      event.feature = found;
-      if (found.get('features')) {
-        event.feature[vcsLayerName] = foundLayer[vcsLayerName];
-      }
-      event.exactPosition = true;
-    }
-    return Promise.resolve(event);
-  }
-
-  /**
-   * @param {InteractionEvent} event
-   * @returns {Promise<InteractionEvent>}
-   * @private
-   */
-  _obliqueHandler(event) {
-    /** @type {null|import("ol").Feature<import("ol/geom/Geometry").default>} */
-    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) => {
-        if (feat) {
-          found = feat[originalFeatureSymbol] || feat;
-        }
-        foundLayer = layer;
-        return true;
-      }, { hitTolerance: this.hitTolerance });
-
-    if (found && foundLayer) {
-      event.feature = found;
-      if (found.get('features')) {
-        event.feature[vcsLayerName] = foundLayer[vcsLayerName];
-      }
-      event.exactPosition = true;
-    }
-    return Promise.resolve(event);
-  }
-
-  /**
-   * @param {InteractionEvent} event
-   * @returns {Promise<InteractionEvent>}
-   * @private
-   */
-  _cesiumHandler(event) {
-    const cesiumMap = /** @type {import("@vcmap/core").CesiumMap} */ (event.map);
-    const scene = cesiumMap.getScene();
-
-    const object = scene.pick(event.windowPosition, this.hitTolerance, this.hitTolerance);
-
-    let scratchCartographic = new Cartographic();
-    let scratchCartesian = new Cartesian3();
-    let scratchPullCartesian = new Cartesian3();
-    const { pickTranslucentDepth } = scene;
-
-    const handlePick = () => {
-      if (!scratchCartesian) {
-        scratchCartesian = new Cartesian3();
-        return Promise.resolve(event);
-      }
-      if (this.pullPickedPosition && event.ray) {
-        scratchPullCartesian = Cartesian3
-          .multiplyByScalar(event.ray.direction, this.pullPickedPosition, scratchPullCartesian);
-
-        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);
-      event.positionOrPixel = event.position;
-      scene.pickTranslucentDepth = pickTranslucentDepth;
-      return Promise.resolve(event);
-    };
-
-    if (object) {
-      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
-        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
-        event.feature = object.id.olFeature;
-      } else if (object.id && object.id[vcsLayerName]) { // entity
-        event.feature = object;
-        event.feature[vcsLayerName] = object.id[vcsLayerName];
-      } else {
-        event.feature = object;
-      }
-
-      if (!(event.type & this.pickPosition)) {
-        return Promise.resolve(event);
-      }
-
-      if (scene.pickPositionSupported) {
-        if (
-          object.primitive &&
-          this.pickTranslucent &&
-          !(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);
-        return handlePick();
-      }
-    }
-    return Promise.resolve(event);
-  }
-}
-
-export default FeatureAtPixelInteraction;