@vcmap/core 5.0.0-rc.1 → 5.0.0-rc.12

package/src/classRegistry.js

@@ -0,0 +1,162 @@
+import { is, check } from '@vcsuite/check';
+import { getLogger } from '@vcsuite/logger';
+import OverrideClassRegistry from './overrideClassRegistry.js';
+
+/**
+ * @returns {import("@vcsuite/logger").Logger}
+ */
+function logger() {
+  return getLogger('ClassRegistry');
+}
+
+/**
+ * @class
+ * @api
+ * @template {Object|import("@vcmap/core").VcsObject} T
+ */
+class ClassRegistry {
+  constructor() {
+    /**
+     * @type {Map<string, function(new: T, ...*)>}
+     * @private
+     */
+    this._classMap = new Map();
+  }
+
+  /**
+   * @returns {Array<string>}
+   */
+  getClassNames() {
+    return [...this._classMap.keys()];
+  }
+
+  /**
+   * Register a class by its class name.
+   * @param {string} className
+   * @param {function(new: T, ...*)} 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);
+  }
+
+  /**
+   * Gets the constructor for a registered class or undefined, if no such class was registerd
+   * @param {string} className
+   * @returns {function(new: T, ...*)|undefined}
+   * @api
+   */
+  getClass(className) {
+    check(className, String);
+
+    if (this._classMap.has(className)) {
+      return this._classMap.get(className);
+    }
+    return undefined;
+  }
+
+  /**
+   * @param {string} className
+   * @returns {boolean}
+   */
+  hasClass(className) {
+    check(className, String);
+
+    return this._classMap.has(className);
+  }
+
+  /**
+   * @param {string} className
+   * @param {...*} args
+   * @returns {T}
+   * @api
+   */
+  create(className, ...args) {
+    check(className, String);
+
+    const Ctor = this.getClass(className);
+    if (!Ctor) {
+      logger().error(`could not find constructor ${className}`);
+      return undefined;
+    }
+    return new Ctor(...args);
+  }
+
+  /**
+   * @param {Object} options
+   * @param {...*} args
+   * @returns {T}
+   */
+  createFromTypeOptions(options, ...args) {
+    check(options, { type: String });
+
+    return this.create(options.type, options, ...args);
+  }
+}
+
+export default ClassRegistry;
+
+/**
+ * @type {ClassRegistry<import("@vcmap/core").Layer>}
+ */
+export const layerClassRegistry = new ClassRegistry();
+/**
+ * @type {ClassRegistry<import("@vcmap/core").TileProvider>}
+ */
+export const tileProviderClassRegistry = new ClassRegistry();
+/**
+ * @type {ClassRegistry<import("@vcmap/core").AbstractFeatureProvider>}
+ */
+export const featureProviderClassRegistry = new ClassRegistry();
+/**
+ * @type {ClassRegistry<import("@vcmap/core").VcsMap>}
+ */
+export const mapClassRegistry = new ClassRegistry();
+/**
+ * @type {ClassRegistry<import("@vcmap/core").StyleItem>}
+ */
+export const styleClassRegistry = new ClassRegistry();
+/**
+ * @type {ClassRegistry<import("@vcmap/core").Category<*>>}
+ */
+export const categoryClassRegistry = new ClassRegistry();
+
+/**
+ * Returns an object based on a class registry or override class registry and a typed options object. as opposed to ClassRegistry.createFromTypedOptions, this function never throws.
+ * @api stable
+ * @template {Object|import("@vcmap/core").VcsObject} T
+ * @param {OverrideClassRegistry<T>|ClassRegistry<T>} classRegistry
+ * @param {Object} options
+ * @param {...*} args
+ * @returns {T|null}
+ */
+export function getObjectFromClassRegistry(classRegistry, options, ...args) { // move to classReg
+  if (!is(classRegistry, [ClassRegistry, OverrideClassRegistry])) {
+    logger().error(`ObjectCreation failed: no class registry provided for ${options}`);
+    return null;
+  }
+
+  if (!options?.type) {
+    logger().warning(`ObjectCreation failed: could not find type in options ${options}`);
+    return null;
+  }
+  let object;
+  try {
+    object = classRegistry.createFromTypeOptions(options, ...args);
+  } catch (ex) {
+    logger().warning(`Error: ${ex}`);
+  }
+
+  if (!object) {
+    logger().warning('ObjectCreation failed: could not create new Object');
+    return null;
+  }
+  return object;
+}

package/src/context.js

@@ -0,0 +1,72 @@
+import { v4 as uuidv4, v5 as uuidv5 } from 'uuid';
+
+/**
+ * @typedef {Object} VcsAppConfig
+ * @property {string|undefined} [id]
+ * @property {Array<LayerOptions>} [layers]
+ * @property {Array<VcsMapOptions>} [maps]
+ * @property {Array<StyleItemOptions>} [styles]
+ * @property {Array<ViewPointOptions>} [viewpoints]
+ * @property {string} [startingViewPointName]
+ * @property {string} [startingMapName]
+ * @property {ProjectionOptions} [projection]
+ * @property {Array<{ name: string, items: Array<Object> }>} [categories]
+ * @property {Array<ObliqueCollectionOptions>} [obliqueCollections]
+ */
+
+/**
+ * @type {string}
+ */
+const uuidNamespace = uuidv4();
+
+/**
+ * @class
+ */
+class Context {
+  /**
+   * @param {VcsAppConfig} config
+   */
+  constructor(config) {
+    /**
+     * @type {VcsAppConfig}
+     * @private
+     */
+    this._config = config;
+    /**
+     * @type {string}
+     * @private
+     */
+    this._checkSum = uuidv5(JSON.stringify(config), uuidNamespace);
+    /**
+     * @type {string}
+     * @private
+     */
+    this._id = config.id || this._checkSum;
+  }
+
+  /**
+   * @type {string}
+   * @readonly
+   */
+  get id() {
+    return this._id;
+  }
+
+  /**
+   * @type {string}
+   * @readonly
+   */
+  get checkSum() {
+    return this._checkSum;
+  }
+
+  /**
+   * @type {VcsAppConfig}
+   * @readonly
+   */
+  get config() {
+    return JSON.parse(JSON.stringify(this._config));
+  }
+}
+
+export default Context;

package/src/{vcs/vcm/util/featureProvider → featureProvider}/abstractFeatureProvider.js

@@ -1,10 +1,10 @@
 import { v4 as uuidv4 } from 'uuid';
 import { parseBoolean } from '@vcsuite/parsers';
-import { vcsLayerName } from '../../layer/layerSymbols.js';
-import VcsObject from '../../object.js';
+import { vcsLayerName } from '../layer/layerSymbols.js';
+import VcsObject from '../vcsObject.js';
 import { getStyleOrDefaultStyle } from '../style/styleFactory.js';
 import { defaultVectorStyle } from '../style/vectorStyleItem.js';
-import VectorProperties from '../../layer/vectorProperties.js';
+import VectorProperties from '../layer/vectorProperties.js';
 import { isProvidedFeature, showProvidedFeature } from './featureProviderSymbols.js';
 
 /**
@@ -22,14 +22,13 @@ import { isProvidedFeature, showProvidedFeature } from './featureProviderSymbols
 
 /**
  * An abstract class providing features for {@link Layer}s which cannot provide features directly, but can provide features for
- * a given location, e.g. WMS with a getFeatureInfo configuration. In this case, a feature provider can be created for this layer.
+ * a given location, e.g. WmsLayer with a getFeatureInfo configuration. In this case, a feature provider can be created for this layer.
  * @class
- * @export
  * @abstract
  * @api
  */
 class AbstractFeatureProvider extends VcsObject {
-  static get className() { return 'vcs.vcm.util.featureProvider.AbstractFeatureProvider'; }
+  static get className() { return 'AbstractFeatureProvider'; }
 
   /**
    * @returns {AbstractFeatureProviderOptions}
@@ -154,9 +153,9 @@ class AbstractFeatureProvider extends VcsObject {
    * @returns {AbstractFeatureProviderOptions}
    * @api
    */
-  getConfigObject() {
+  toJSON() {
     const config =
-      /** @type {AbstractFeatureProviderOptions} */ (super.getConfigObject());
+      /** @type {AbstractFeatureProviderOptions} */ (super.toJSON());
 
     const defaultOptions = AbstractFeatureProvider.getDefaultOptions();
     delete config.name; // the name is irrelevant, since its the layers name
@@ -170,7 +169,7 @@ class AbstractFeatureProvider extends VcsObject {
     }
 
     if (this.style) {
-      config.style = this.style.getOptions();
+      config.style = this.style.toJSON();
     }
 
     const vectorPropertiesConfig = this.vectorProperties

package/src/{vcs/vcm/util/featureProvider → featureProvider}/featureProviderHelpers.js

@@ -1,6 +1,6 @@
 import { getCenter } from 'ol/extent.js';
-import Projection from '../projection.js';
-import { createOrUpdateFromGeometry } from '../featureconverter/extent3d.js';
+import Projection from '../util/projection.js';
+import Extent3D from '../util/featureconverter/extent3D.js';
 
 /**
  * @param {VectorClickedObject} feature
@@ -32,9 +32,8 @@ export function getGenericFeatureFromProvidedFeature(feature, layer) {
 
   let heightOffset = clickedPosition.height;
   if (!isModel) {
-    const extent = createOrUpdateFromGeometry(geometry);
-    const max = Number.isFinite(extent[5]) ? extent[5] : 0;
-    heightOffset = max;
+    const extent = Extent3D.fromGeometry(geometry);
+    heightOffset = Number.isFinite(extent.maxZ) ? extent.maxZ : 0;
   }
   const relativeToGround = !isModel && feature.get('olcs_altitudeMode') === 'relativeToGround';
 

package/src/{vcs/vcm/util/featureProvider → featureProvider}/tileProviderFeatureProvider.js

@@ -1,4 +1,5 @@
 import AbstractFeatureProvider from './abstractFeatureProvider.js';
+import { featureProviderClassRegistry } from '../classRegistry.js';
 
 
 /**
@@ -12,7 +13,7 @@ import AbstractFeatureProvider from './abstractFeatureProvider.js';
  * @extends {AbstractFeatureProvider}
  */
 class TileProviderFeatureProvider extends AbstractFeatureProvider {
-  static get className() { return 'vcs.vcm.util.featureProvider.TileProviderFeatureProvider'; }
+  static get className() { return 'TileProviderFeatureProvider'; }
 
   /**
    * @param {string} layerName
@@ -26,7 +27,7 @@ class TileProviderFeatureProvider extends AbstractFeatureProvider {
      * @type {Array<string>}
      * @api
      */
-    this.mapTypes = ['vcs.vcm.maps.Cesium'];
+    this.mapTypes = ['CesiumMap'];
 
     /**
      * TileProvider
@@ -60,3 +61,4 @@ class TileProviderFeatureProvider extends AbstractFeatureProvider {
 }
 
 export default TileProviderFeatureProvider;
+featureProviderClassRegistry.registerClass(TileProviderFeatureProvider.className, TileProviderFeatureProvider);

package/src/{vcs/vcm/util/featureProvider → featureProvider}/wmsFeatureProvider.js

@@ -1,4 +1,3 @@
-import axios from 'axios';
 import GML2 from 'ol/format/GML2.js';
 import WFS from 'ol/format/WFS.js';
 import GeoJSON from 'ol/format/GeoJSON.js';
@@ -7,14 +6,16 @@ import Point from 'ol/geom/Point.js';
 import { getTransform } from 'ol/proj.js';
 import { parseInteger } from '@vcsuite/parsers';
 import AbstractFeatureProvider from './abstractFeatureProvider.js';
-import Projection, { mercatorProjection } from '../projection.js';
-import { getWMSSource } from '../../layer/wmsHelpers.js';
-import Extent from '../extent.js';
+import Projection, { mercatorProjection } from '../util/projection.js';
+import { getWMSSource } from '../layer/wmsHelpers.js';
+import Extent from '../util/extent.js';
+import { requestJson } from '../util/fetch.js';
+import { featureProviderClassRegistry } from '../classRegistry.js';
 
 /**
  * @typedef {AbstractFeatureProviderOptions} WMSFeatureProviderOptions
  * @property {string|undefined} [responseType='text/xml'] - the response type for the feature info
- * @property {Object|undefined} formatOptions - format options for the GeoJSON, WFS or GML format. To overwrite the gmlFormat option in WFS format, use 'GML', 'GML2' or 'GML3' as string
+ * @property {Object|undefined} formatOptions - format options for the GeojsonLayer, WfsLayer or GML format. To overwrite the gmlFormat option in WfsLayer format, use 'GML', 'GML2' or 'GML3' as string
  * @property {ProjectionOptions|undefined} projection - the projection of the data, if not encoded in the response
  * @property {string} url
  * @property {string} [tilingSchema='geographic'] -  either "geographic" or "mercator"
@@ -67,11 +68,10 @@ export function getFormat(responseType, options = {}) {
 
 /**
  * @class
- * @export
  * @extends {AbstractFeatureProvider}
  */
 class WMSFeatureProvider extends AbstractFeatureProvider {
-  static get className() { return 'vcs.vcm.util.featureProvider.WMSFeatureProvider'; }
+  static get className() { return 'WMSFeatureProvider'; }
 
   /**
    * @returns {WMSFeatureProviderOptions}
@@ -124,7 +124,7 @@ class WMSFeatureProvider extends AbstractFeatureProvider {
       version: options.version || defaultOptions.version,
     };
     /**
-     * The WMS Source used to generate getFeatureInfo urls
+     * The WmsLayer Source used to generate getFeatureInfo urls
      * @type {import("ol/source/TileWMS").default}
      * @api
      */
@@ -155,12 +155,11 @@ class WMSFeatureProvider extends AbstractFeatureProvider {
   }
 
   /**
-   * @param {import("axios").AxiosResponse<*>} response
+   * @param {import("ol/format/GeoJSON").GeoJSONObject} data
    * @param {import("ol/coordinate").Coordinate} coordinate
    * @returns {Array<import("ol").Feature<import("ol/geom/Geometry").default>>}
    */
-  featureResponseCallback(response, coordinate) {
-    const { data } = response;
+  featureResponseCallback(data, coordinate) {
     /** @type {Array<import("ol").Feature<import("ol/geom/Geometry").default>>} */
     let features;
 
@@ -199,7 +198,8 @@ class WMSFeatureProvider extends AbstractFeatureProvider {
     let coords = coordinate;
     if (projection) {
       const transform = getTransform(mercatorProjection.proj, projection);
-      coords = transform(coordinate.slice());
+      // error in TransformFunction type definition, remove undefined after openlayer fixed the type
+      coords = transform(coordinate.slice(), undefined, undefined);
     }
 
     const metersPerUnit = 111194.87428468118;
@@ -211,8 +211,14 @@ class WMSFeatureProvider extends AbstractFeatureProvider {
     );
 
     if (url) {
-      const response = await axios.get(url);
-      return this.featureResponseCallback(response, coordinate)
+      let data;
+      try {
+        data = await requestJson(url);
+      } catch (ex) {
+        this.getLogger().error(`Failed fetching WMS FeatureInfo ${url}`);
+        return [];
+      }
+      return this.featureResponseCallback(data, coordinate)
         .map(f => this.getProviderFeature(f));
     }
     return [];
@@ -222,8 +228,8 @@ class WMSFeatureProvider extends AbstractFeatureProvider {
    * @inheritDoc
    * @returns {WMSFeatureProviderOptions}
    */
-  getConfigObject() {
-    const config = /** @type {WMSFeatureProviderOptions} */ (super.getConfigObject());
+  toJSON() {
+    const config = /** @type {WMSFeatureProviderOptions} */ (super.toJSON());
     const defaultOptions = WMSFeatureProvider.getDefaultOptions();
     if (this.featureInfoResponseType !== defaultOptions.responseType) {
       config.responseType = this.featureInfoResponseType;
@@ -234,7 +240,7 @@ class WMSFeatureProvider extends AbstractFeatureProvider {
     }
 
     if (this.projection !== defaultOptions.projection) {
-      config.projection = this.projection.getConfigObject();
+      config.projection = this.projection.toJSON();
     }
 
     config.url = this._wmsSourceOptions.url;
@@ -259,7 +265,7 @@ class WMSFeatureProvider extends AbstractFeatureProvider {
       config.tileSize = this._wmsSourceOptions.tileSize.slice();
     }
     if (this.extent) {
-      config.extent = this.extent.getConfigObject();
+      config.extent = this.extent.toJSON();
     }
 
     return config;
@@ -278,3 +284,4 @@ class WMSFeatureProvider extends AbstractFeatureProvider {
 }
 
 export default WMSFeatureProvider;
+featureProviderClassRegistry.registerClass(WMSFeatureProvider.className, WMSFeatureProvider);

package/src/{vcs/vcm/interaction → interaction}/abstractInteraction.js

@@ -22,12 +22,20 @@ import { EventType, ModificationKeyType, PointerKeyType } from './interactionTyp
 /**
  * An abstract interface for all interactions
  * @class
- * @export
  * @abstract
  * @api
  */
 class AbstractInteraction {
-  constructor() {
+  /**
+   * @param {number} [defaultActive=EventType.NONE] - A bitmask representing the default {@link EventType} to listen to
+   * @param {number} [defaultModificationKey=ModificationKeyType.NONE] - A bitmask representing the default {@link ModificationKeyType} keys to listen to
+   * @param {number} [defaultPointerKey=PointerKeyType.LEFT] - A bitmask representing the {@link PointerKeyType} pointer key to listen to
+   */
+  constructor(
+    defaultActive = EventType.NONE,
+    defaultModificationKey = ModificationKeyType.NONE,
+    defaultPointerKey = PointerKeyType.LEFT,
+  ) {
     /**
      * A unique identifier for this interaction
      * @type {string}
@@ -36,13 +44,10 @@ class AbstractInteraction {
     this.id = uuidv4();
 
     /**
-     * A bitmask representing the default events to listen to
-     * {@link EventType}, default is NONE
      * @type {number}
-     * @protected
-     * @api
+     * @private
      */
-    this._defaultActive = EventType.NONE;
+    this._defaultActive = defaultActive;
 
     /**
      * The current active bitmask for {@link EventType}
@@ -52,13 +57,10 @@ class AbstractInteraction {
     this.active = this._defaultActive;
 
     /**
-     * The default bitmask for modification keys to listen to,
-     * {@link ModificationKeyType} default is NONE
      * @type {number}
-     * @protected
-     * @api
+     * @private
      */
-    this._defaultModificationKey = ModificationKeyType.NONE;
+    this._defaultModificationKey = defaultModificationKey;
 
     /**
      * The current active {@link ModificationKeyType}
@@ -68,11 +70,10 @@ class AbstractInteraction {
     this.modificationKey = this._defaultModificationKey;
 
     /**
-     * default bitmask for pointer key {@link PointerKeyType}, starting value is LEFT
      * @type {number}
-     * @protected
+     * @private
      */
-    this._defaultPointerKey = PointerKeyType.LEFT;
+    this._defaultPointerKey = defaultPointerKey;
 
     /**
      * The currently active {@link PointerKeyType}
@@ -114,7 +115,7 @@ class AbstractInteraction {
   }
 
   /**
-   * Sets the modification key to listen to
+   * Sets the modification key to listen to or the default modification key if none is provided.
    * @param {number=} mod
    * @api
    */
@@ -127,8 +128,8 @@ class AbstractInteraction {
   }
 
   /**
-   * Sets the pointer key for this interaction$
-   * @param {number} pointer
+   * Sets the pointer key for this interaction or the default pointer if none is provided.
+   * @param {number=} pointer
    * @api
    */
   setPointer(pointer) {

package/src/{vcs/vcm/interaction → interaction}/coordinateAtPixel.js

@@ -10,7 +10,7 @@ import { transformFromImage } from '../oblique/helpers.js';
  */
 class CoordinateAtPixel extends AbstractInteraction {
   constructor() {
-    super();
+    super(EventType.ALL, ModificationKeyType.ALL);
     /**
      * @type {import("@vcmap/cesium").Cartographic}
      * @private
@@ -22,9 +22,6 @@ class CoordinateAtPixel extends AbstractInteraction {
      */
     this._scratchCartesian = new Cartesian3();
 
-    this._defaultActive = EventType.ALL;
-    this._defaultModificationKey = ModificationKeyType.ALL;
-
     this.setActive();
   }
 
@@ -35,9 +32,9 @@ class CoordinateAtPixel extends AbstractInteraction {
    */
   // eslint-disable-next-line class-methods-use-this
   async pipe(event) {
-    if (event.map.className === 'vcs.vcm.maps.Cesium') {
+    if (event.map.className === 'CesiumMap') {
       return this._cesiumHandler(event);
-    } else if (event.map.className === 'vcs.vcm.maps.Oblique') {
+    } else if (event.map.className === 'ObliqueMap') {
       return CoordinateAtPixel.obliqueHandler(event);
     }
     return event;
@@ -74,10 +71,10 @@ class CoordinateAtPixel extends AbstractInteraction {
    * @private
    */
   static obliqueHandler(event) {
-    const obliqueMap = /** @type {import("@vcmap/core").Oblique} */ (event.map);
+    const obliqueMap = /** @type {import("@vcmap/core").ObliqueMap} */ (event.map);
     const image = obliqueMap.currentImage;
     if (image) {
-      // don't use Terrain for coordinate Transformation if the event is a move or drag event,
+      // don't use TerrainLayer for coordinate Transformation if the event is a move or drag event,
       // to avoid requesting the terrain each mousemove...
       // XXX but what about DRAGSTART and DRAGEND? this could be usefull, no?
       const move = event.type & (EventType.MOVE ^ EventType.DRAGEVENTS);
@@ -85,7 +82,7 @@ class CoordinateAtPixel extends AbstractInteraction {
       if (Number.isFinite(pixel[0]) && Number.isFinite(pixel[1])) {
         return transformFromImage(image, pixel, {
           dontUseTerrain: !!move,
-          dataProjection: mercatorProjection.proj,
+          dataProjection: mercatorProjection,
         }).then((coordinates) => {
           event.obliqueParameters = { pixel };
           event.position = coordinates.coords;

package/src/{vcs/vcm/interaction → interaction}/eventHandler.js

@@ -9,7 +9,7 @@ import CoordinateAtPixel from './coordinateAtPixel.js';
 import FeatureAtPixelInteraction from './featureAtPixelInteraction.js';
 import { EventType, PointerEventType } from './interactionType.js';
 import FeatureProviderInteraction from './featureProviderInteraction.js';
-import VcsEvent from '../event/vcsEvent.js';
+import VcsEvent from '../vcsEvent.js';
 
 /**
  * @namespace interaction
@@ -31,7 +31,7 @@ import VcsEvent from '../event/vcsEvent.js';
  * @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 Oblique Map Mode
+ * @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
  */
@@ -47,7 +47,7 @@ import VcsEvent from '../event/vcsEvent.js';
  * @returns {import("@vcsuite/logger").Logger}
  */
 function getLogger() {
-  return getLoggerByName('vcs.vcm.interaction.EventHandler');
+  return getLoggerByName('EventHandler');
 }
 
 /**