@vcmap/core 5.0.0-rc.0

package/src/ol/geom/geometryCollection.js

@@ -0,0 +1,33 @@
+import GeometryCollection from 'ol/geom/GeometryCollection.js';
+import GeometryLayout from 'ol/geom/GeometryLayout.js';
+import { check } from '@vcsuite/check';
+
+/**
+ * @returns {Array<import("ol/coordinate").Coordinate|Array<import("ol/coordinate").Coordinate>|Array<Array<import("ol/coordinate").Coordinate>>|Array<Array<Array<import("ol/coordinate").Coordinate>>>>}
+ */
+GeometryCollection.prototype.getCoordinates = function getCoordinates() {
+  return this.getGeometries().map(g => g.getCoordinates());
+};
+
+/**
+ * @param {Array<import("ol/coordinate").Coordinate|Array<import("ol/coordinate").Coordinate>|Array<Array<import("ol/coordinate").Coordinate>>|Array<Array<Array<import("ol/coordinate").Coordinate>>>>} coordinates
+ * @param {import("ol/geom/GeometryLayout").default=} optLayout
+ */
+GeometryCollection.prototype.setCoordinates = function setCoordinates(coordinates, optLayout) {
+  check(coordinates, Array);
+  check(coordinates.length, this.getGeometries().length);
+
+  this.setGeometries(this.getGeometries()
+    .map((g, i) => { g.setCoordinates(coordinates[i], optLayout); return g; }));
+};
+
+/**
+ * @returns {import("ol/geom/GeometryLayout").default}
+ */
+GeometryCollection.prototype.getLayout = function getLayout() {
+  const firstGeom = this.getGeometries()[0];
+  if (firstGeom) {
+    return firstGeom.getLayout();
+  }
+  return /** @type {undefined} */ (GeometryLayout.XYZ);
+};

package/src/ol/render/canvas/canvasTileRenderer.js

@@ -0,0 +1,179 @@
+// @ts-nocheck
+import CanvasImmediateRenderer from 'ol/render/canvas/Immediate.js';
+import { intersects } from 'ol/extent.js';
+import { transformGeom2D } from 'ol/geom/SimpleGeometry.js';
+import { transform2D } from 'ol/geom/flat/transform.js';
+
+/**
+ * @class
+ * @extends {CanvasImmediateRenderer}
+ * @memberOf ol
+ * @exports
+ * Tile Renderer Implementation of openlayers CanvasImmediateRenderer
+ * can be used to allow for a correction Factor to take into account Mercator Tile distortion
+ */
+class CanvasTileRenderer extends CanvasImmediateRenderer {
+  /**
+   * @param {CanvasRenderingContext2D} context Context.
+   * @param {number} pixelRatio Pixel ratio.
+   * @param {import("ol/extent").Extent} extent Extent.
+   * @param {import("ol/transform").Transform} transform Transform.
+   * @param {number} viewRotation View rotation.
+   * @param {number=} squaredTolerance Optional squared tolerance for simplification.
+   * @param {import("ol/proj").TransformFunction=} userTransform Transform from user to view projection.
+   * @param {number} [scaleY=1] Scale value for Scaling Circles, Images, Text in Y direction.
+   */
+  constructor(
+    context,
+    pixelRatio,
+    extent,
+    transform,
+    viewRotation,
+    squaredTolerance,
+    userTransform,
+    scaleY = 1,
+  ) {
+    super(context, pixelRatio, extent, transform, viewRotation, squaredTolerance, userTransform);
+
+    /**
+     * @private
+     * @type {number}
+     */
+    this.scaleY = scaleY;
+
+    /**
+     * @private
+     * @type {import("ol/size").Size}
+     */
+    this.scaledImageScale_ = [0, 0];
+
+    /**
+     * @private
+     * @type {import("ol/size").Size}
+     */
+    this.scaledTextScale_ = [0, 0];
+  }
+
+  /**
+   * @private
+   * @type {import("ol/size").Size}
+   */
+  get imageScale_() {
+    return this.scaledImageScale_;
+  }
+
+  /**
+   * @private
+   * @param {import("ol/size").Size} value
+   */
+  set imageScale_(value) {
+    const imageScale = value || [1, 1];
+    this.scaledImageScale_ = [
+      imageScale[0],
+      imageScale[1] * this.scaleY,
+    ];
+  }
+
+  /**
+   * @private
+   * @type {import("ol/size").Size}
+   */
+  get textScale_() {
+    return this.scaledTextScale_;
+  }
+
+  /**
+   * @private
+   * @param {import("ol/size").Size} value
+   */
+  set textScale_(value) {
+    const textScale = value || [1, 1];
+    this.scaledTextScale_ = [
+      textScale[0],
+      textScale[1] * this.scaleY,
+    ];
+  }
+
+  /**
+   * @param {Array<number>} flatCoordinates Flat coordinates.
+   * @param {number} offset Offset.
+   * @param {number} end End.
+   * @param {number} stride Stride.
+   * @param {boolean} close Close.
+   * @private
+   * @returns {number} end End.
+   */
+  moveToLineTo_(flatCoordinates, offset, end, stride, close) {
+    const context = this.context_;
+    const pixelCoordinates = transform2D(
+      flatCoordinates,
+      offset,
+      end,
+      stride,
+      this.transform_,
+      this.pixelCoordinates_,
+    );
+    context.moveTo(pixelCoordinates[0], pixelCoordinates[1]);
+    const { length } = pixelCoordinates;
+    for (let i = 2; i < length; i += 2) {
+      context.lineTo(pixelCoordinates[i], pixelCoordinates[i + 1]);
+    }
+    if (close) {
+      context.closePath();
+    }
+    return end;
+  }
+
+  /**
+   * Render a circle geometry into the canvas.  Rendering is immediate and uses
+   * the current fill and stroke styles.
+   *
+   * takes the mercator yscale into account and draws a ellipse instead of a circle.
+   *
+   * @param {import("ol/geom/Circle").default} geometry Circle geometry.
+   * @api
+   */
+  drawCircle(geometry) {
+    if (!intersects(this.extent_, geometry.getExtent())) {
+      return;
+    }
+    if (this.fillState_ || this.strokeState_) {
+      if (this.fillState_) {
+        this.setContextFillState_(this.fillState_);
+      }
+      if (this.strokeState_) {
+        this.setContextStrokeState_(this.strokeState_);
+      }
+      const pixelCoordinates = transformGeom2D(
+        geometry,
+        this.transform_,
+        this.pixelCoordinates_,
+      );
+      const dx = pixelCoordinates[2] - pixelCoordinates[0];
+      const dy = pixelCoordinates[3] - pixelCoordinates[1];
+      const radius = Math.sqrt(dx * dx + dy * dy);
+      const context = this.context_;
+      context.beginPath();
+      context.ellipse(
+        pixelCoordinates[0],
+        pixelCoordinates[1],
+        radius,
+        radius * this.scaleY,
+        0,
+        0,
+        2 * Math.PI,
+      );
+      if (this.fillState_) {
+        context.fill();
+      }
+      if (this.strokeState_) {
+        context.stroke();
+      }
+    }
+    if (this.text_ !== '') {
+      this.drawText_(geometry.getCenter(), 0, 2, 2);
+    }
+  }
+}
+
+export default CanvasTileRenderer;

package/src/ol/source/ClusterEnhancedVectorSource.js

@@ -0,0 +1,39 @@
+import { getUid } from 'ol/util.js';
+import VectorSource from 'ol/source/Vector.js';
+
+/**
+ * @class
+ * @extends {import("ol/source").Vector<import("ol/geom/Geometry").default>}
+ * @memberOf ol
+ */
+class ClusterEnhancedVectorSource extends VectorSource {
+  /**
+   * @param {import("ol").Feature<import("ol/geom/Geometry").default>} feature
+   * @param {boolean=} silent
+   */
+  removeFeature(feature, silent) {
+    const featureKey = getUid(feature);
+    if (featureKey in this.nullGeometryFeatures_) {
+      delete this.nullGeometryFeatures_[featureKey];
+    } else if (this.featuresRtree_) {
+      this.featuresRtree_.remove(feature);
+    }
+    this.removeFeatureInternal(feature);
+    if (!silent) {
+      this.changed();
+    }
+  }
+
+  /**
+   * @param {import("ol").Feature<import("ol/geom/Geometry").default>} feature
+   * @param {boolean=} silent
+   */
+  addFeature(feature, silent) {
+    this.addFeatureInternal(feature);
+    if (!silent) {
+      this.changed();
+    }
+  }
+}
+
+export default ClusterEnhancedVectorSource;

package/src/ol/source/VcsCluster.js

@@ -0,0 +1,37 @@
+import Cluster from 'ol/source/Cluster.js';
+
+/**
+ * @class
+ * @extends {import("ol/source/Cluster").default}
+ * @memberOf ol
+ */
+class VcsCluster extends Cluster {
+  constructor(props) {
+    super(props);
+    /**
+     * @type {boolean}
+     */
+    this._paused = false;
+  }
+
+  pause() {
+    this._paused = true;
+  }
+
+  resume() {
+    this._paused = false;
+  }
+
+  isPaused() {
+    return this._paused;
+  }
+
+  refresh() {
+    if (this._paused) {
+      return;
+    }
+    super.refresh();
+  }
+}
+
+export default VcsCluster;

package/src/vcs/vcm/classRegistry.js

@@ -0,0 +1,106 @@
+import { check } from '@vcsuite/check';
+import { getLogger } from '@vcsuite/logger';
+
+/**
+ * @class
+ * @api
+ */
+class ClassRegistry {
+  constructor() {
+    /**
+     * @type {Map<string, function():(function(new: *, ...*)|Promise<function(new: *, ...*)>)>}
+     * @private
+     */
+    this._classMap = new Map();
+    /**
+     * @type {import("@vcsuite/logger").Logger}
+     */
+    this.logger = getLogger('vcs.vcm.ClassRegistry');
+  }
+
+  /**
+   * Register a class by its class name.
+   * @param {string} className
+   * @param {function(new: *, ...*)} ctor
+   * @api
+   */
+  registerClass(className, ctor) {
+    check(className, String);
+    check(ctor, Function);
+
+    if (this._classMap.has(className)) {
+      throw new Error('a constructor with this className has already been registered');
+    }
+
+    this._classMap.set(className, () => ctor);
+  }
+
+  /**
+   * @param {string} className
+   * @param {function():Promise<function(new: *, ...*)>} cb - a callback providing a promise which returns the constructor on resolve.
+   * used for lazy loading modules, e.g
+   * <code>ClassRegistry.registerDeferredClass(() => import('my-module').then(({ default: MyCtor }) => MyCtor));</code>
+   * @api
+   */
+  registerDeferredClass(className, cb) {
+    check(className, String);
+    check(cb, Function);
+
+    this._classMap.set(className, cb);
+  }
+
+  /**
+   * Gets the constructor for a registered class or undefined, if no such class was registerd
+   * @param {string} className
+   * @returns {function(new: *, ...*)|Promise<*>|undefined}
+   * @api
+   */
+  getClass(className) {
+    if (this._classMap.has(className)) {
+      return this._classMap.get(className)();
+    }
+    return undefined;
+  }
+
+  /**
+   * @param {string} className
+   * @param {...*} args
+   * @returns {Promise<*>}
+   * @api
+   */
+  async create(className, ...args) {
+    check(className, String);
+
+    const Ctor = await this.getClass(className);
+    if (!Ctor) {
+      this.logger.error(`could not find constructor ${className}`);
+      return undefined;
+    }
+    return new Ctor(...args);
+  }
+
+  /**
+   * @param {string} className
+   * @param {...*} args
+   * @returns {*}
+   * @deprecated 4.0
+   */
+  createSync(className, ...args) {
+    check(className, String);
+
+    const Ctor = /** @type {function(new: *, ...*)} */ (this.getClass(className));
+    if (!Ctor) {
+      this.logger.error(`could not find constructor ${className}`);
+      return undefined;
+    }
+    return new Ctor(...args);
+  }
+}
+
+export default ClassRegistry;
+
+/**
+ * @export
+ * @type {ClassRegistry}
+ */
+export const VcsClassRegistry = new ClassRegistry();

package/src/vcs/vcm/event/vcsEvent.js

@@ -0,0 +1,89 @@
+/**
+ * @class
+ * @template {*} T
+ * @export
+ * @api
+ */
+class VcsEvent {
+  constructor() {
+    /**
+     * @type {Set<function(T=): Promise<void>|void>}
+     * @private
+     */
+    this._listeners = new Set();
+  }
+
+  /**
+   * The number of listeners
+   * @type {number}
+   * @readonly
+   * @api
+   */
+  get numberOfListeners() {
+    return this._listeners.size;
+  }
+
+  /**
+   * Adds an event listener. An event listener can only be added once.
+   * A listener added multiple times will only be called once.
+   * @param {function(T=): Promise<void>|void} listener
+   * @returns {function(): void} - remove callback. call this function to remove the listener
+   * @api
+   */
+  addEventListener(listener) {
+    this._listeners.add(listener);
+    return () => {
+      this.removeEventListener(listener);
+    };
+  }
+
+  /**
+   * Removes the provided listener
+   * @param {function(T=): Promise<void>|void} listener
+   * @returns {boolean} - whether a listener was removed
+   * @api
+   */
+  removeEventListener(listener) {
+    if (this._listeners.has(listener)) {
+      this._listeners.delete(listener);
+      return true;
+    }
+
+    return false;
+  }
+
+  /**
+   * Raise the event, calling all listeners
+   * @param {T=} event
+   * @api
+   */
+  raiseEvent(event) {
+    this._listeners.forEach((cb) => {
+      cb(event);
+    });
+  }
+
+  /**
+   * @param {T=} event
+   * @returns {Promise<void>}
+   */
+  async awaitRaisedEvent(event) {
+    const promises = new Array(this._listeners.size);
+    let i = 0;
+    this._listeners.forEach((cb) => {
+      promises[i] = cb(event);
+      i += 1;
+    });
+    await Promise.all(promises);
+  }
+
+  /**
+   * clears all listeners
+   * @api
+   */
+  destroy() {
+    this._listeners.clear();
+  }
+}
+
+export default VcsEvent;

package/src/vcs/vcm/globalCollections.js

@@ -0,0 +1,11 @@
+import Collection from './util/collection.js';
+
+/**
+ * @type {import("@vcmap/core").Collection<import("@vcmap/core").StyleItem>}
+ */
+export const styleCollection = new Collection();
+
+/**
+ * @type {import("@vcmap/core").Collection<import("@vcmap/core").ObliqueCollection>}
+ */
+export const obliqueCollectionCollection = new Collection();

package/src/vcs/vcm/interaction/abstractInteraction.js

@@ -0,0 +1,149 @@
+import { v4 as uuidv4 } from 'uuid';
+import { EventType, ModificationKeyType, PointerKeyType } from './interactionType.js';
+
+/**
+ * @typedef {Object} ObliqueParameters
+ * @property {import("ol/coordinate").Coordinate} pixel - the image pixel clicked
+ * @property {boolean|undefined} estimate - true if the terrain could not be taken into account
+ * @api
+ */
+
+/**
+ * @typedef {MapEvent} InteractionEvent
+ * @property {EventType} type
+ * @property {undefined|import("ol").Feature<import("ol/geom/Geometry").default>|import("@vcmap/cesium").Cesium3DTileFeature|import("@vcmap/cesium").Cesium3DTilePointFeature} feature - a potential feature at said location
+ * @property {boolean|undefined} stopPropagation - if set to true, the event chain is interrupted
+ * @property {undefined|ObliqueParameters} obliqueParameters - additional parameters from oblique if obliquemode is active
+ * @property {import("@vcmap/cesium").Ray|undefined} ray - potential ray
+ * @property {boolean|undefined} exactPosition - whether the position is exact, eg with translucentDepthPicking on
+ * @api
+ */
+
+/**
+ * An abstract interface for all interactions
+ * @class
+ * @export
+ * @abstract
+ * @api
+ */
+class AbstractInteraction {
+  constructor() {
+    /**
+     * A unique identifier for this interaction
+     * @type {string}
+     * @api
+     */
+    this.id = uuidv4();
+
+    /**
+     * A bitmask representing the default events to listen to
+     * {@link EventType}, default is NONE
+     * @type {number}
+     * @protected
+     * @api
+     */
+    this._defaultActive = EventType.NONE;
+
+    /**
+     * The current active bitmask for {@link EventType}
+     * @type {number}
+     * @api
+     */
+    this.active = this._defaultActive;
+
+    /**
+     * The default bitmask for modification keys to listen to,
+     * {@link ModificationKeyType} default is NONE
+     * @type {number}
+     * @protected
+     * @api
+     */
+    this._defaultModificationKey = ModificationKeyType.NONE;
+
+    /**
+     * The current active {@link ModificationKeyType}
+     * @type {number}
+     * @api
+     */
+    this.modificationKey = this._defaultModificationKey;
+
+    /**
+     * default bitmask for pointer key {@link PointerKeyType}, starting value is LEFT
+     * @type {number}
+     * @protected
+     */
+    this._defaultPointerKey = PointerKeyType.LEFT;
+
+    /**
+     * The currently active {@link PointerKeyType}
+     * @type {number}
+     */
+    this.pointerKey = this._defaultPointerKey;
+  }
+
+  /**
+   * Main function, called when an event is raised for this interaction
+   * @param {InteractionEvent} event
+   * @returns {Promise<InteractionEvent>}
+   * @api
+   */
+  // eslint-disable-next-line class-methods-use-this
+  async pipe(event) {
+    return event;
+  }
+
+  /**
+   * Sets the interaction active.
+   * Use boolean (true|false) to toggle default behavior.
+   * Pass it a bitmask of {@link EventType}
+   * to change the active state.
+   * Call without arguments to reset the default active, modification key and pointer Key behavior
+   * @param {(boolean|number)=} active
+   * @api
+   */
+  setActive(active) {
+    if (typeof active === 'undefined') {
+      this.active = this._defaultActive;
+      this.modificationKey = this._defaultModificationKey;
+      this.pointerKey = this._defaultPointerKey;
+    } else if (typeof active === 'boolean') {
+      this.active = active ? this._defaultActive : EventType.NONE;
+    } else {
+      this.active = active;
+    }
+  }
+
+  /**
+   * Sets the modification key to listen to
+   * @param {number=} mod
+   * @api
+   */
+  setModification(mod) {
+    if (mod) {
+      this.modificationKey = mod;
+    } else {
+      this.modificationKey = this._defaultModificationKey;
+    }
+  }
+
+  /**
+   * Sets the pointer key for this interaction$
+   * @param {number} pointer
+   * @api
+   */
+  setPointer(pointer) {
+    if (pointer) {
+      this.pointerKey = pointer;
+    } else {
+      this.pointerKey = this._defaultPointerKey;
+    }
+  }
+
+  /**
+   * destroys the implementation, removing any created resources
+   */
+  // eslint-disable-next-line class-methods-use-this
+  destroy() {}
+}
+
+export default AbstractInteraction;