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

package/src/category/categoryCollection.js

@@ -35,14 +35,16 @@ class CategoryCollection extends IndexedCollection {
      * @type {Function}
      * @private
      */
-    this._moduleRemovedListener = this._app.moduleRemoved.addEventListener((module) => {
-      this._cache.forEach((moduleMap, name) => {
-        moduleMap.delete(module._id);
-        if (moduleMap.size === 0) {
-          this._cache.delete(name);
-        }
-      });
-    });
+    this._moduleRemovedListener = this._app.moduleRemoved.addEventListener(
+      (module) => {
+        this._cache.forEach((moduleMap, name) => {
+          moduleMap.delete(module._id);
+          if (moduleMap.size === 0) {
+            this._cache.delete(name);
+          }
+        });
+      },
+    );
   }
 
   /**
@@ -50,7 +52,8 @@ class CategoryCollection extends IndexedCollection {
    * @param {Category<Object|import("@vcmap/core").VcsObject>} category
    * @returns {number|null}
    */
-  add(category) { // XXX use a symbol to enforce using request over add?
+  add(category) {
+    // XXX use a symbol to enforce using request over add?
     if (this.hasKey(category.name)) {
       return null;
     }
@@ -58,11 +61,9 @@ class CategoryCollection extends IndexedCollection {
     category.setApp(this._app);
     const added = super.add(category);
     if (added != null && this._cache.has(category.name)) {
-      this._cache
-        .get(category.name)
-        .forEach((items, moduleId) => {
-          this.parseCategoryItems(category.name, items, moduleId);
-        });
+      this._cache.get(category.name).forEach((items, moduleId) => {
+        this.parseCategoryItems(category.name, items, moduleId);
+      });
 
       this._cache.delete(category.name);
     }
@@ -73,7 +74,8 @@ class CategoryCollection extends IndexedCollection {
    * Categories should be static. Removing them can lead to undefined behavior.
    * @param {Category<Object|import("@vcmap/core").VcsObject>} category
    */
-  remove(category) { // XXX add logger warning?
+  remove(category) {
+    // XXX add logger warning?
     super.remove(category);
     this._cache.delete(category.name);
   }
@@ -110,7 +112,9 @@ class CategoryCollection extends IndexedCollection {
     }
 
     if (!options.type) {
-      getLogger().warning(`Implicitly typing category ${options.name} as ${Category.className}`);
+      getLogger().warning(
+        `Implicitly typing category ${options.name} as ${Category.className}`,
+      );
       options.type = Category.className;
     }
 
@@ -119,7 +123,10 @@ class CategoryCollection extends IndexedCollection {
       category = this.getByKey(options.name);
       category.mergeOptions(options);
     } else {
-      category = await getObjectFromClassRegistry(this._app.categoryClassRegistry, options);
+      category = await getObjectFromClassRegistry(
+        this._app.categoryClassRegistry,
+        options,
+      );
       if (category) {
         if (this.add(category) == null) {
           return null;
@@ -128,7 +135,9 @@ class CategoryCollection extends IndexedCollection {
     }
 
     if (!category) {
-      throw new Error(`Category ${options.name} with type ${options.type} could not be created`);
+      throw new Error(
+        `Category ${options.name} with type ${options.type} could not be created`,
+      );
     }
     return category;
   }

package/src/cesium/cesiumVcsCameraPrimitive.js

@@ -43,7 +43,8 @@ class VcsCameraPrimitive {
     this.show = typeof options.show === 'undefined' ? true : options.show;
     this._camera = options.camera;
     this._color = options.color || Color.YELLOW;
-    this.allowPicking = typeof options.allowPicking === 'undefined' ? true : options.allowPicking;
+    this.allowPicking =
+      typeof options.allowPicking === 'undefined' ? true : options.allowPicking;
     this.id = options.id || {};
   }
 
@@ -74,7 +75,10 @@ class VcsCameraPrimitive {
       Matrix3.setColumn(rotation, 1, up, rotation);
       Matrix3.setColumn(rotation, 2, direction, rotation);
 
-      const orientation = Quaternion.fromRotationMatrix(rotation, scratchOrientation);
+      const orientation = Quaternion.fromRotationMatrix(
+        rotation,
+        scratchOrientation,
+      );
 
       planesPrimitives.length = 1;
       outlinePrimitives.length = 1;
@@ -92,7 +96,9 @@ class VcsCameraPrimitive {
             _drawNearPlane: true,
           }),
           attributes: {
-            color: ColorGeometryInstanceAttribute.fromColor(Color.fromAlpha(this._color, 0.1, scratchColor)),
+            color: ColorGeometryInstanceAttribute.fromColor(
+              Color.fromAlpha(this._color, 0.1, scratchColor),
+            ),
           },
           id: this.id,
           pickPrimitive: this,
@@ -136,8 +142,10 @@ class VcsCameraPrimitive {
   destroy() {
     const { length } = this._planesPrimitives;
     for (let i = 0; i < length; ++i) {
-      this._outlinePrimitives[i] = this._outlinePrimitives[i] && this._outlinePrimitives[i].destroy();
-      this._planesPrimitives[i] = this._planesPrimitives[i] && this._planesPrimitives[i].destroy();
+      this._outlinePrimitives[i] =
+        this._outlinePrimitives[i] && this._outlinePrimitives[i].destroy();
+      this._planesPrimitives[i] =
+        this._planesPrimitives[i] && this._planesPrimitives[i].destroy();
     }
     return destroyObject(this);
   }

package/src/cesium/entity.js

@@ -22,6 +22,8 @@ Entity.prototype.getProperty = function getProperty(property) {
  * @param {string} property
  * @returns {*}
  */
-Entity.prototype.getPropertyInherited = function getPropertyInherited(property) {
+Entity.prototype.getPropertyInherited = function getPropertyInherited(
+  property,
+) {
   return this.getProperty(property);
 };

package/src/cesium/wallpaperMaterial.js

@@ -15,8 +15,10 @@ Material._materialCache.addMaterial('Wallpaper', {
       anchor: new Cartesian2(0, 0),
     },
     components: {
-      diffuse: 'texture2D(image, fract((gl_FragCoord.xy - anchor.xy) / vec2(imageDimensions.xy))).rgb',
-      alpha: 'texture2D(image, fract((gl_FragCoord.xy - anchor.xy) / vec2(imageDimensions.xy))).a',
+      diffuse:
+        'texture2D(image, fract((gl_FragCoord.xy - anchor.xy) / vec2(imageDimensions.xy))).rgb',
+      alpha:
+        'texture2D(image, fract((gl_FragCoord.xy - anchor.xy) / vec2(imageDimensions.xy))).a',
     },
   },
   translucent: false,

package/src/classRegistry.js

@@ -41,7 +41,9 @@ class ClassRegistry {
     check(ctor, Function);
 
     if (this._classMap.has(className)) {
-      throw new Error('a constructor with this className has already been registered');
+      throw new Error(
+        'a constructor with this className has already been registered',
+      );
     }
 
     this._classMap.set(className, ctor);
@@ -137,14 +139,19 @@ export const categoryClassRegistry = new ClassRegistry();
  * @param {...*} args
  * @returns {T|null}
  */
-export function getObjectFromClassRegistry(classRegistry, options, ...args) { // move to classReg
+export function getObjectFromClassRegistry(classRegistry, options, ...args) {
+  // move to classReg
   if (!is(classRegistry, [ClassRegistry, OverrideClassRegistry])) {
-    logger().error(`ObjectCreation failed: no class registry provided for ${options}`);
+    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}`);
+    logger().warning(
+      `ObjectCreation failed: could not find type in options ${options}`,
+    );
     return null;
   }
   let object;

package/src/featureProvider/abstractFeatureProvider.js

@@ -5,7 +5,10 @@ import VcsObject from '../vcsObject.js';
 import { getStyleOrDefaultStyle } from '../style/styleFactory.js';
 import { defaultVectorStyle } from '../style/vectorStyleItem.js';
 import VectorProperties from '../layer/vectorProperties.js';
-import { isProvidedFeature, showProvidedFeature } from './featureProviderSymbols.js';
+import {
+  isProvidedFeature,
+  showProvidedFeature,
+} from './featureProviderSymbols.js';
 
 /**
  * @namespace featureProvider
@@ -27,7 +30,9 @@ import { isProvidedFeature, showProvidedFeature } from './featureProviderSymbols
  * @api
  */
 class AbstractFeatureProvider extends VcsObject {
-  static get className() { return 'AbstractFeatureProvider'; }
+  static get className() {
+    return 'AbstractFeatureProvider';
+  }
 
   /**
    * @returns {AbstractFeatureProviderOptions}
@@ -60,29 +65,38 @@ class AbstractFeatureProvider extends VcsObject {
      * @type {import("@vcmap/core").StyleItem|undefined}
      * @api
      */
-    this.style = options.style ?
-      getStyleOrDefaultStyle(options.style, defaultVectorStyle.clone()) :
-      undefined;
+    this.style = options.style
+      ? getStyleOrDefaultStyle(options.style, defaultVectorStyle.clone())
+      : undefined;
     /**
      * Whether to show the geometry on selection.
      * @type {boolean}
      * @api
      */
-    this.showGeometry = parseBoolean(options.showGeometry, defaultOptions.showGeometry);
+    this.showGeometry = parseBoolean(
+      options.showGeometry,
+      defaultOptions.showGeometry,
+    );
     /**
      * The vector properties assigned to features created by this provider
      * @type {import("@vcmap/core").VectorProperties}
      * @api
      */
-    this.vectorProperties = options.vectorProperties instanceof VectorProperties ?
-      options.vectorProperties :
-      new VectorProperties({ ...defaultOptions.vectorProperties, ...options.vectorProperties });
+    this.vectorProperties =
+      options.vectorProperties instanceof VectorProperties
+        ? options.vectorProperties
+        : new VectorProperties({
+            ...defaultOptions.vectorProperties,
+            ...options.vectorProperties,
+          });
     /**
      * Map ClassNames Can be used to only apply this featureProvider to the specified maps
      * @type {Array<string>}
      * @api
      */
-    this.mapTypes = Array.isArray(options.mapTypes) ? options.mapTypes : defaultOptions.mapTypes;
+    this.mapTypes = Array.isArray(options.mapTypes)
+      ? options.mapTypes
+      : defaultOptions.mapTypes;
   }
 
   /**
@@ -92,8 +106,10 @@ class AbstractFeatureProvider extends VcsObject {
    * @api stable
    */
   isSupported(map) {
-    return map &&
-      (this.mapTypes.length === 0 || this.mapTypes.includes(map.className));
+    return (
+      map &&
+      (this.mapTypes.length === 0 || this.mapTypes.includes(map.className))
+    );
   }
 
   /**
@@ -113,12 +129,14 @@ class AbstractFeatureProvider extends VcsObject {
     feature[vcsLayerName] = this.layerName;
     feature[isProvidedFeature] = true;
     feature[showProvidedFeature] = this.showGeometry;
-    Object.entries(this.vectorProperties.getValues()).forEach(([key, value]) => {
-      const olcsKey = `olcs_${key}`;
-      if (feature.get(olcsKey) === undefined && value !== undefined) {
-        feature.set(olcsKey, value);
-      }
-    });
+    Object.entries(this.vectorProperties.getValues()).forEach(
+      ([key, value]) => {
+        const olcsKey = `olcs_${key}`;
+        if (feature.get(olcsKey) === undefined && value !== undefined) {
+          feature.set(olcsKey, value);
+        }
+      },
+    );
     return feature;
   }
 
@@ -142,8 +160,9 @@ class AbstractFeatureProvider extends VcsObject {
    * @api
    */
   toJSON() {
-    const config =
-      /** @type {AbstractFeatureProviderOptions} */ (super.toJSON());
+    const config = /** @type {AbstractFeatureProviderOptions} */ (
+      super.toJSON()
+    );
 
     const defaultOptions = AbstractFeatureProvider.getDefaultOptions();
     delete config.name; // the name is irrelevant, since its the layers name
@@ -156,8 +175,10 @@ class AbstractFeatureProvider extends VcsObject {
       config.style = this.style.toJSON();
     }
 
-    const vectorPropertiesConfig = this.vectorProperties
-      .getVcsMeta({ ...VectorProperties.getDefaultOptions(), ...defaultOptions.vectorProperties });
+    const vectorPropertiesConfig = this.vectorProperties.getVcsMeta({
+      ...VectorProperties.getDefaultOptions(),
+      ...defaultOptions.vectorProperties,
+    });
     if (Object.keys(vectorPropertiesConfig).length > 0) {
       config.vectorProperties = vectorPropertiesConfig;
     }

package/src/featureProvider/tileProviderFeatureProvider.js

@@ -1,7 +1,6 @@
 import AbstractFeatureProvider from './abstractFeatureProvider.js';
 import { featureProviderClassRegistry } from '../classRegistry.js';
 
-
 /**
  * @typedef {AbstractFeatureProviderOptions} TileProviderFeatureProviderOptions
  * @property {import("@vcmap/core").TileProvider} tileProvider
@@ -13,7 +12,9 @@ import { featureProviderClassRegistry } from '../classRegistry.js';
  * @extends {AbstractFeatureProvider}
  */
 class TileProviderFeatureProvider extends AbstractFeatureProvider {
-  static get className() { return 'TileProviderFeatureProvider'; }
+  static get className() {
+    return 'TileProviderFeatureProvider';
+  }
 
   /**
    * @param {string} layerName
@@ -37,7 +38,6 @@ class TileProviderFeatureProvider extends AbstractFeatureProvider {
     this.tileProvider = options.tileProvider;
   }
 
-
   /**
    * @inheritDoc
    * @param {import("ol/coordinate").Coordinate} coordinate
@@ -45,7 +45,10 @@ class TileProviderFeatureProvider extends AbstractFeatureProvider {
    * @returns {Promise<Array<import("ol").Feature<import("ol/geom/Geometry").default>>>}
    */
   async getFeaturesByCoordinate(coordinate, resolution) {
-    const features = await this.tileProvider.getFeaturesByCoordinate(coordinate, resolution);
+    const features = await this.tileProvider.getFeaturesByCoordinate(
+      coordinate,
+      resolution,
+    );
     return features.filter((feature) => {
       return this.vectorProperties.getAllowPicking(feature);
     });
@@ -61,4 +64,7 @@ class TileProviderFeatureProvider extends AbstractFeatureProvider {
 }
 
 export default TileProviderFeatureProvider;
-featureProviderClassRegistry.registerClass(TileProviderFeatureProvider.className, TileProviderFeatureProvider);
+featureProviderClassRegistry.registerClass(
+  TileProviderFeatureProvider.className,
+  TileProviderFeatureProvider,
+);

package/src/featureProvider/wmsFeatureProvider.js

@@ -52,7 +52,9 @@ const geojsonFormats = [
  */
 export function getFormat(responseType, options = {}) {
   if (responseType === 'text/xml') {
-    options.gmlFormat = options.gmlFormat ? new gmlFormats[options.gmlFormat]() : new GML2();
+    options.gmlFormat = options.gmlFormat
+      ? new gmlFormats[options.gmlFormat]()
+      : new GML2();
     return new WFS(options);
   }
   if (geojsonFormats.includes(responseType)) {
@@ -61,7 +63,10 @@ export function getFormat(responseType, options = {}) {
   if (responseType === 'application/vnd.ogc.gml') {
     return new GML2(options);
   }
-  if (responseType === 'application/vnd.ogc.gml/3.1.1' || responseType === 'text/xml; subtype=gml/3.1.1') {
+  if (
+    responseType === 'application/vnd.ogc.gml/3.1.1' ||
+    responseType === 'text/xml; subtype=gml/3.1.1'
+  ) {
     return new GML3(options);
   }
   return null;
@@ -72,7 +77,9 @@ export function getFormat(responseType, options = {}) {
  * @extends {AbstractFeatureProvider}
  */
 class WMSFeatureProvider extends AbstractFeatureProvider {
-  static get className() { return 'WMSFeatureProvider'; }
+  static get className() {
+    return 'WMSFeatureProvider';
+  }
 
   /**
    * @returns {WMSFeatureProviderOptions}
@@ -135,7 +142,8 @@ class WMSFeatureProvider extends AbstractFeatureProvider {
      * @type {string}
      * @api
      */
-    this.featureInfoResponseType = options.responseType || defaultOptions.responseType;
+    this.featureInfoResponseType =
+      options.responseType || defaultOptions.responseType;
     /**
      * @type {Object}
      * @private
@@ -146,13 +154,18 @@ class WMSFeatureProvider extends AbstractFeatureProvider {
      * @type {import("ol/format/Feature").default}
      * @api
      */
-    this.featureFormat = getFormat(this.featureInfoResponseType, options.formatOptions);
+    this.featureFormat = getFormat(
+      this.featureInfoResponseType,
+      options.formatOptions,
+    );
     /**
      * The feature response projection, if not present in the response format.
      * @type {Projection}
      * @api
      */
-    this.projection = options.projection ? new Projection(options.projection) : undefined;
+    this.projection = options.projection
+      ? new Projection(options.projection)
+      : undefined;
   }
 
   /**
@@ -165,13 +178,18 @@ class WMSFeatureProvider extends AbstractFeatureProvider {
     let features;
 
     try {
-      features = /** @type {Array<import("ol").Feature<import("ol/geom/Geometry").default>>} */
-      (this.featureFormat.readFeatures(data, {
-        dataProjection: this.projection ? this.projection.proj : undefined,
-        featureProjection: mercatorProjection.proj,
-      }));
+      features =
+        /** @type {Array<import("ol").Feature<import("ol/geom/Geometry").default>>} */
+        (
+          this.featureFormat.readFeatures(data, {
+            dataProjection: this.projection ? this.projection.proj : undefined,
+            featureProjection: mercatorProjection.proj,
+          })
+        );
     } catch (ex) {
-      this.getLogger().warning('Features could not be read, please verify the featureInfoResponseType with the capabilities from the server');
+      this.getLogger().warning(
+        'Features could not be read, please verify the featureInfoResponseType with the capabilities from the server',
+      );
       return [];
     }
 
@@ -219,8 +237,9 @@ class WMSFeatureProvider extends AbstractFeatureProvider {
         this.getLogger().error(`Failed fetching WMS FeatureInfo ${url}`);
         return [];
       }
-      return this.featureResponseCallback(data, coordinate)
-        .map(f => this.getProviderFeature(f));
+      return this.featureResponseCallback(data, coordinate).map((f) =>
+        this.getProviderFeature(f),
+      );
     }
     return [];
   }
@@ -285,4 +304,7 @@ class WMSFeatureProvider extends AbstractFeatureProvider {
 }
 
 export default WMSFeatureProvider;
-featureProviderClassRegistry.registerClass(WMSFeatureProvider.className, WMSFeatureProvider);
+featureProviderClassRegistry.registerClass(
+  WMSFeatureProvider.className,
+  WMSFeatureProvider,
+);

package/src/interaction/abstractInteraction.js

@@ -1,5 +1,9 @@
 import { v4 as uuidv4 } from 'uuid';
-import { EventType, ModificationKeyType, PointerKeyType } from './interactionType.js';
+import {
+  EventType,
+  ModificationKeyType,
+  PointerKeyType,
+} from './interactionType.js';
 
 /**
  * @typedef {Object} ObliqueParameters

package/src/interaction/coordinateAtPixel.js

@@ -1,7 +1,15 @@
-import { Cartographic, Cartesian3, Math as CesiumMath } from '@vcmap-cesium/engine';
+import {
+  Cartographic,
+  Cartesian3,
+  Math as CesiumMath,
+} from '@vcmap-cesium/engine';
 import AbstractInteraction from './abstractInteraction.js';
 import Projection, { mercatorProjection } from '../util/projection.js';
-import { EventType, ModificationKeyType, PointerKeyType } from './interactionType.js';
+import {
+  EventType,
+  ModificationKeyType,
+  PointerKeyType,
+} from './interactionType.js';
 import { transformFromImage } from '../oblique/helpers.js';
 
 /**
@@ -46,20 +54,32 @@ class CoordinateAtPixel 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();
     event.ray = scene.camera.getPickRay(event.windowPosition);
-    const pickResult = scene.globe.pick(event.ray, scene, this._scratchCartesian);
+    const pickResult = scene.globe.pick(
+      event.ray,
+      scene,
+      this._scratchCartesian,
+    );
     if (!pickResult) {
       event.position = [0, 0, 0];
     } else {
-      this._scratchCartographic = Cartographic
-        .fromCartesian(pickResult, scene.globe.ellipsoid, this._scratchCartographic);
-      event.position = Projection.wgs84ToMercator([
-        CesiumMath.toDegrees(this._scratchCartographic.longitude),
-        CesiumMath.toDegrees(this._scratchCartographic.latitude),
-        this._scratchCartographic.height,
-      ], true);
+      this._scratchCartographic = Cartographic.fromCartesian(
+        pickResult,
+        scene.globe.ellipsoid,
+        this._scratchCartographic,
+      );
+      event.position = Projection.wgs84ToMercator(
+        [
+          CesiumMath.toDegrees(this._scratchCartographic.longitude),
+          CesiumMath.toDegrees(this._scratchCartographic.latitude),
+          this._scratchCartographic.height,
+        ],
+        true,
+      );
     }
     event.positionOrPixel = event.position;
     return Promise.resolve(event);
@@ -71,7 +91,9 @@ class CoordinateAtPixel extends AbstractInteraction {
    * @private
    */
   static obliqueHandler(event) {
-    const obliqueMap = /** @type {import("@vcmap/core").ObliqueMap} */ (event.map);
+    const obliqueMap = /** @type {import("@vcmap/core").ObliqueMap} */ (
+      event.map
+    );
     const image = obliqueMap.currentImage;
     if (image) {
       // don't use TerrainLayer for coordinate Transformation if the event is a move or drag event,