@vcmap/core 5.0.0-rc.3 → 5.0.0-rc.30

package/src/layer/vectorHelpers.js

@@ -0,0 +1,129 @@
+import { unByKey } from 'ol/Observable.js';
+import { FeatureVisibilityAction } from './featureVisibility.js';
+
+/**
+ * Added to ol.source.Vector to determine, when the source has last had an update to its features visibility.
+ * @type {symbol}
+ */
+export const fvLastUpdated = Symbol('FVlastUpdated');
+
+/**
+ * Added to ol.source.Vector to determine, when the source has last had an update to its features global visibility.
+ * @type {symbol}
+ */
+export const globalHiderLastUpdated = Symbol('GlobalHiderLastUpdated');
+
+/**
+ * @param {import("@vcmap/core").FeatureVisibility} featureVisibility
+ * @param {import("ol/source").Vector<import("ol/geom/Geometry").default>} source
+ */
+export function updateFeatureVisibility(featureVisibility, source) {
+  Object.keys(featureVisibility.highlightedObjects).forEach((id) => {
+    const feat = source.getFeatureById(id);
+    if (feat && !featureVisibility.hasHighlightFeature(id, feat)) {
+      featureVisibility.addHighlightFeature(id, feat);
+    }
+  });
+
+  Object.keys(featureVisibility.hiddenObjects).forEach((id) => {
+    const feat = source.getFeatureById(id);
+    if (feat && !featureVisibility.hasHiddenFeature(id, feat)) {
+      featureVisibility.addHiddenFeature(id, feat);
+    }
+  });
+  source[fvLastUpdated] = Date.now();
+}
+
+/**
+ * @param {import("@vcmap/core").GlobalHider} globalHider
+ * @param {import("ol/source").Vector<import("ol/geom/Geometry").default>} source
+ */
+export function updateGlobalHider(globalHider, source) {
+  Object.keys(globalHider.hiddenObjects).forEach((id) => {
+    const feat = source.getFeatureById(id);
+    if (feat && !globalHider.hasFeature(id, feat)) {
+      globalHider.addFeature(id, feat);
+    }
+  });
+  source[globalHiderLastUpdated] = Date.now();
+}
+
+/**
+ * @param {import("@vcmap/core").FeatureVisibility} featureVisibility
+ * @param {import("ol/source").Vector<import("ol/geom/Geometry").default>} source
+ * @param {import("@vcmap/core").GlobalHider} globalHider
+ * @returns {Array<Function>}
+ */
+export function synchronizeFeatureVisibilityWithSource(
+  featureVisibility,
+  source,
+  globalHider,
+) {
+  const sourceListener = source.on('addfeature', ({ feature }) => {
+    const id = feature.getId();
+    if (featureVisibility.highlightedObjects[id]) {
+      featureVisibility.addHighlightFeature(id, feature);
+    }
+
+    if (featureVisibility.hiddenObjects[id]) {
+      featureVisibility.addHiddenFeature(id, feature);
+    }
+
+    if (globalHider.hiddenObjects[id]) {
+      globalHider.addFeature(id, feature);
+    }
+    const now = Date.now();
+    source[fvLastUpdated] = now;
+    source[globalHiderLastUpdated] = now;
+  });
+
+  if (
+    !source[fvLastUpdated] ||
+    source[fvLastUpdated] < featureVisibility.lastUpdated
+  ) {
+    updateFeatureVisibility(featureVisibility, source);
+  }
+
+  if (
+    !source[globalHiderLastUpdated] ||
+    source[globalHiderLastUpdated] < featureVisibility.lastUpdated
+  ) {
+    updateGlobalHider(globalHider, source);
+  }
+
+  return [
+    featureVisibility.changed.addEventListener(({ action, ids }) => {
+      if (action === FeatureVisibilityAction.HIGHLIGHT) {
+        ids.forEach((id) => {
+          const feat = source.getFeatureById(id);
+          if (feat) {
+            featureVisibility.addHighlightFeature(id, feat);
+          }
+        });
+        source[fvLastUpdated] = Date.now();
+      } else if (action === FeatureVisibilityAction.HIDE) {
+        ids.forEach((id) => {
+          const feat = source.getFeatureById(id);
+          if (feat) {
+            featureVisibility.addHiddenFeature(id, feat);
+          }
+        });
+        source[fvLastUpdated] = Date.now();
+      }
+    }),
+    globalHider.changed.addEventListener(({ action, ids }) => {
+      if (action === FeatureVisibilityAction.HIDE) {
+        ids.forEach((id) => {
+          const feat = source.getFeatureById(id);
+          if (feat) {
+            globalHider.addFeature(id, feat);
+          }
+        });
+        source[globalHiderLastUpdated] = Date.now();
+      }
+    }),
+    () => {
+      unByKey(sourceListener);
+    },
+  ];
+}

package/src/{vcs/vcm/layer/vector.js → layer/vectorLayer.js}

@@ -4,11 +4,17 @@ import Feature from 'ol/Feature.js';
 import { v4 as uuidv4 } from 'uuid';
 import { check } from '@vcsuite/check';
 import { parseBoolean } from '@vcsuite/parsers';
-import Projection, { getDefaultProjection, mercatorProjection } from '../util/projection.js';
+import Projection, {
+  getDefaultProjection,
+  mercatorProjection,
+} from '../util/projection.js';
 import Layer, { vcsMetaVersion } from './layer.js';
-import VectorStyleItem, { defaultVectorStyle, vectorStyleSymbol } from '../util/style/vectorStyleItem.js';
-import DeclarativeStyleItem from '../util/style/declarativeStyleItem.js';
-import writeStyle from '../util/style/writeStyle.js';
+import VectorStyleItem, {
+  defaultVectorStyle,
+  vectorStyleSymbol,
+} from '../style/vectorStyleItem.js';
+import DeclarativeStyleItem from '../style/declarativeStyleItem.js';
+import writeStyle from '../style/writeStyle.js';
 import {
   alreadyTransformedToImage,
   alreadyTransformedToMercator,
@@ -19,16 +25,15 @@ import {
 import Extent from '../util/extent.js';
 import VectorProperties from './vectorProperties.js';
 import FeatureLayer from './featureLayer.js';
-import Openlayers from '../maps/openlayers.js';
-import VectorOpenlayers from './openlayers/vectorOpenlayers.js';
-import VectorCesium from './cesium/vectorCesium.js';
-import VectorOblique from './oblique/vectorOblique.js';
-import Oblique from '../maps/oblique.js';
-import CesiumMap from '../maps/cesium.js';
+import OpenlayersMap from '../map/openlayersMap.js';
+import VectorOpenlayersImpl from './openlayers/vectorOpenlayersImpl.js';
+import VectorCesiumImpl from './cesium/vectorCesiumImpl.js';
+import VectorObliqueImpl from './oblique/vectorObliqueImpl.js';
+import ObliqueMap from '../map/obliqueMap.js';
+import CesiumMap from '../map/cesiumMap.js';
 import { originalStyle, updateOriginalStyle } from './featureVisibility.js';
-import StyleItem, { referenceableStyleSymbol, StyleType } from '../util/style/styleItem.js';
-import { getGenericFeatureFromClickedObject } from './vectorHelpers.js';
-import { VcsClassRegistry } from '../classRegistry.js';
+import StyleItem from '../style/styleItem.js';
+import { layerClassRegistry } from '../classRegistry.js';
 
 /**
  * @typedef {FeatureLayerOptions} VectorOptions
@@ -47,11 +52,11 @@ import { VcsClassRegistry } from '../classRegistry.js';
  * @typedef {Object} VectorGeometryFactoryType
  * @property {function(Array<import("ol/geom/SimpleGeometry").default>):Array<import("ol/coordinate").Coordinate>} getCoordinates
  * @property {function(import("ol/geom/SimpleGeometry").default, number):Object} getGeometryOptions
- * @property {function(Object, number, boolean, number=):Array<import("@vcmap/cesium").PolygonGeometry|import("@vcmap/cesium").CircleGeometry|import("@vcmap/cesium").WallGeometry>} createSolidGeometries
- * @property {function(Object, number, boolean, number=):Array<import("@vcmap/cesium").CircleOutlineGeometry|import("@vcmap/cesium").WallOutlineGeometry|import("@vcmap/cesium").PolygonOutlineGeometry>} createOutlineGeometries
- * @property {function(Object, number, boolean):Array<import("@vcmap/cesium").CircleGeometry|import("@vcmap/cesium").PolygonGeometry>} createFillGeometries
- * @property {function(Object, import("ol/style/Style").default):Array<import("@vcmap/cesium").GroundPolylineGeometry>} createGroundLineGeometries
- * @property {function(Object, import("ol/style/Style").default):Array<import("@vcmap/cesium").PolylineGeometry>} createLineGeometries
+ * @property {function(Object, number, boolean, number=):Array<import("@vcmap-cesium/engine").PolygonGeometry|import("@vcmap-cesium/engine").CircleGeometry|import("@vcmap-cesium/engine").WallGeometry>} createSolidGeometries
+ * @property {function(Object, number, boolean, number=):Array<import("@vcmap-cesium/engine").CircleOutlineGeometry|import("@vcmap-cesium/engine").WallOutlineGeometry|import("@vcmap-cesium/engine").PolygonOutlineGeometry>} createOutlineGeometries
+ * @property {function(Object, number, boolean):Array<import("@vcmap-cesium/engine").CircleGeometry|import("@vcmap-cesium/engine").PolygonGeometry>} createFillGeometries
+ * @property {function(Object, import("ol/style/Style").default):Array<import("@vcmap-cesium/engine").GroundPolylineGeometry>} createGroundLineGeometries
+ * @property {function(Object, import("ol/style/Style").default):Array<import("@vcmap-cesium/engine").PolylineGeometry>} createLineGeometries
  * @api
  */
 
@@ -63,7 +68,7 @@ import { VcsClassRegistry } from '../classRegistry.js';
  * @property {number} groundLevel - the level above or below mean sea level (minZ value or ground_level or 0)
  * @property {number} skirt - a negative height to <i>push</i> the geometry visually into the ground
  * @property {boolean} perPositionHeight
- * @property {import("@vcmap/cesium").HeightReference} heightReference heightReference of the feature.
+ * @property {import("@vcmap-cesium/engine").HeightReference} heightReference heightReference of the feature.
  * @property {number} heightAboveGroundAdjustment
  * @api
  */
@@ -82,48 +87,60 @@ import { VcsClassRegistry } from '../classRegistry.js';
  */
 
 /**
- * Vector Layer for Openlayers, Cesium and Oblique
+ * VectorLayer Layer for OpenlayersMap, Cesium and ObliqueMap
  * @class
- * @export
  * @extends {FeatureLayer}
+ * @implements {SplitLayer}
  * @api stable
  */
-class Vector extends FeatureLayer {
+class VectorLayer extends FeatureLayer {
   /**
    * @readonly
    * @returns {string}
    */
-  static get className() { return 'vcs.vcm.layer.Vector'; }
+  static get className() {
+    return 'VectorLayer';
+  }
 
   /**
    * @returns {symbol}
    * @readonly
    */
-  static get alreadyTransformedToMercator() { return alreadyTransformedToMercator; }
+  static get alreadyTransformedToMercator() {
+    return alreadyTransformedToMercator;
+  }
 
   /**
    * @returns {symbol}
    * @readonly
    */
-  static get alreadyTransformedToImage() { return alreadyTransformedToImage; }
+  static get alreadyTransformedToImage() {
+    return alreadyTransformedToImage;
+  }
 
   /**
    * @returns {symbol}
    * @readonly
    */
-  static get obliqueGeometry() { return obliqueGeometry; }
+  static get obliqueGeometry() {
+    return obliqueGeometry;
+  }
 
   /**
    * @returns {symbol}
    * @readonly
    */
-  static get doNotTransform() { return doNotTransform; }
+  static get doNotTransform() {
+    return doNotTransform;
+  }
 
   /**
    * @returns {symbol}
    * @readonly
    */
-  static get originalFeatureSymbol() { return originalFeatureSymbol; }
+  static get originalFeatureSymbol() {
+    return originalFeatureSymbol;
+  }
 
   /**
    * @returns {VectorOptions}
@@ -150,11 +167,11 @@ class Vector extends FeatureLayer {
 
     this._supportedMaps = [
       CesiumMap.className,
-      Oblique.className,
-      Openlayers.className,
+      ObliqueMap.className,
+      OpenlayersMap.className,
     ];
 
-    const defaultOptions = Vector.getDefaultOptions();
+    const defaultOptions = VectorLayer.getDefaultOptions();
     /** @type {import("ol/source").Vector<import("ol/geom/Geometry").default>} */
     this.source = new VectorSource({});
 
@@ -162,21 +179,32 @@ class Vector extends FeatureLayer {
     this.projection = new Projection(options.projection);
 
     /** @type {?number} */
-    this.maxResolution = options.maxResolution != null ? options.maxResolution : defaultOptions.maxResolution;
+    this.maxResolution =
+      options.maxResolution != null
+        ? options.maxResolution
+        : defaultOptions.maxResolution;
 
     /** @type {?number} */
-    this.minResolution = options.minResolution != null ? options.minResolution : defaultOptions.minResolution;
+    this.minResolution =
+      options.minResolution != null
+        ? options.minResolution
+        : defaultOptions.minResolution;
 
     /** @type {boolean} */
-    this.dontUseTerrainForOblique =
-      parseBoolean(options.dontUseTerrainForOblique, defaultOptions.dontUseTerrainForOblique);
+    this.dontUseTerrainForOblique = parseBoolean(
+      options.dontUseTerrainForOblique,
+      defaultOptions.dontUseTerrainForOblique,
+    );
 
     /** @type {import("@vcmap/core").VectorStyleItem} */
-    this.highlightStyle = /** @type {undefined} */ (defaultOptions.highlightStyle);
+    this.highlightStyle = /** @type {undefined} */ (
+      defaultOptions.highlightStyle
+    );
     if (options.highlightStyle) {
-      this.highlightStyle = options.highlightStyle instanceof VectorStyleItem ?
-        options.highlightStyle :
-        new VectorStyleItem(options.highlightStyle);
+      this.highlightStyle =
+        options.highlightStyle instanceof VectorStyleItem
+          ? options.highlightStyle
+          : new VectorStyleItem(options.highlightStyle);
     }
 
     /**
@@ -213,17 +241,12 @@ class Vector extends FeatureLayer {
     });
 
     let initialStyle = options.style;
-    if (options.activeStyleName) {
-      initialStyle = {
-        type: StyleType.REFERENCE,
-        name: options.activeStyleName,
-      };
-    } else if (options.style instanceof StyleItem) {
-      initialStyle = options.style.getOptions();
+    if (options.style instanceof StyleItem) {
+      initialStyle = options.style.toJSON();
     }
 
     /**
-     * @type {Reference|StyleItemOptions|string}
+     * @type {StyleItemOptions}
      * @private
      */
     this._initialStyle = initialStyle;
@@ -249,7 +272,9 @@ class Vector extends FeatureLayer {
    * @type {boolean}
    * @api
    */
-  get visibility() { return this._visibility; }
+  get visibility() {
+    return this._visibility;
+  }
 
   /**
    * @param {boolean} visible
@@ -266,10 +291,9 @@ class Vector extends FeatureLayer {
    * @returns {Promise<void>}
    */
   initialize() {
-    return super.initialize()
-      .then(() => {
-        this._trackStyleChanges();
-      });
+    return super.initialize().then(() => {
+      this._trackStyleChanges();
+    });
   }
 
   /**
@@ -294,6 +318,10 @@ class Vector extends FeatureLayer {
       // TODO embed icons here by running over all features? this is never used anywhere
     }
 
+    if (Object.keys(this.properties).length !== 0) {
+      vcsMeta.layerProperties = { ...this.properties };
+    }
+
     return vcsMeta;
   }
 
@@ -301,8 +329,12 @@ class Vector extends FeatureLayer {
    * Sets the meta values based on a {@link VcsMeta} Object. Does not carry over the style
    * @param {VcsMeta} vcsMeta
    */
-  setVcsMeta(vcsMeta) { // XXX what about the style?
+  setVcsMeta(vcsMeta) {
+    // XXX what about the style?
     this.vectorProperties.setVcsMeta(vcsMeta);
+    if (vcsMeta.layerProperties) {
+      Object.assign(this.properties, vcsMeta.layerProperties);
+    }
   }
 
   /**
@@ -321,40 +353,43 @@ class Vector extends FeatureLayer {
   /**
    * @inheritDoc
    * @param {import("@vcmap/core").VcsMap} map
-   * @returns {Array<VectorOblique|VectorCesium|VectorOpenlayers>}
+   * @returns {Array<VectorObliqueImpl|VectorCesiumImpl|VectorOpenlayersImpl>}
    */
   createImplementationsForMap(map) {
     if (!this.visibility) {
       return [];
     }
 
-    if (map instanceof Openlayers) {
-      return [new VectorOpenlayers(map, this.getImplementationOptions())];
+    if (map instanceof OpenlayersMap) {
+      return [new VectorOpenlayersImpl(map, this.getImplementationOptions())];
     }
 
     if (map instanceof CesiumMap) {
-      return [new VectorCesium(map, this.getImplementationOptions())];
+      return [new VectorCesiumImpl(map, this.getImplementationOptions())];
     }
 
-    if (map instanceof Oblique) {
-      return [new VectorOblique(map, this.getImplementationOptions())];
+    if (map instanceof ObliqueMap) {
+      return [new VectorObliqueImpl(map, this.getImplementationOptions())];
     }
 
     return [];
   }
 
   /**
-   * @param {(Reference|DeclarativeStyleItemOptions|VectorStyleItemOptions|import("@vcmap/core").StyleItem|string)=} styleOptions
+   * @param {(DeclarativeStyleItemOptions|VectorStyleItemOptions|import("@vcmap/core").StyleItem)=} styleOptions
    * @param {import("@vcmap/core").VectorStyleItem=} defaultStyle
    * @returns {import("@vcmap/core").StyleItem}
    */
   getStyleOrDefaultStyle(styleOptions, defaultStyle) {
-    return super.getStyleOrDefaultStyle(styleOptions, defaultStyle || defaultVectorStyle.clone());
+    return super.getStyleOrDefaultStyle(
+      styleOptions,
+      defaultStyle || defaultVectorStyle.clone(),
+    );
   }
 
   /**
    * sets the style of this layer
-   * @param {import("ol/style/Style").default|import("ol/style/Style").StyleFunction|import("@vcmap/core").StyleItem|string} style
+   * @param {import("ol/style/Style").default|import("ol/style/Style").StyleFunction|import("@vcmap/core").StyleItem} style
    * @param {boolean=} silent
    */
   setStyle(style, silent) {
@@ -390,13 +425,15 @@ class Vector extends FeatureLayer {
     }
 
     const isDeclarative = this.style instanceof DeclarativeStyleItem;
-    this._onStyleChangeRemover = this.style.styleChanged.addEventListener(() => {
-      this.getFeatures().forEach((f) => {
-        if (isDeclarative || !f[vectorStyleSymbol]) {
-          f.changed();
-        }
-      });
-    });
+    this._onStyleChangeRemover = this.style.styleChanged.addEventListener(
+      () => {
+        this.getFeatures().forEach((f) => {
+          if (isDeclarative || !f[vectorStyleSymbol]) {
+            f.changed();
+          }
+        });
+      },
+    );
   }
 
   /**
@@ -453,9 +490,9 @@ class Vector extends FeatureLayer {
         if (this.projection.epsg !== mercatorProjection.epsg) {
           const geometry = feature.getGeometry();
           if (geometry) {
-            if (!geometry[Vector.alreadyTransformedToMercator]) {
+            if (!geometry[VectorLayer.alreadyTransformedToMercator]) {
               geometry.transform(this.projection.proj, mercatorProjection.proj);
-              geometry[Vector.alreadyTransformedToMercator] = true;
+              geometry[VectorLayer.alreadyTransformedToMercator] = true;
             }
           }
         }
@@ -467,9 +504,13 @@ class Vector extends FeatureLayer {
 
         return feature;
       })
-      .filter(f => f);
-    this.source.addFeatures(/** @type {Array<import("ol").Feature<import("ol/geom/Geometry").default>>} */ (toAdd));
-    return features.map(f => f.getId());
+      .filter((f) => f);
+    this.source.addFeatures(
+      /** @type {Array<import("ol").Feature<import("ol/geom/Geometry").default>>} */ (
+        toAdd
+      ),
+    );
+    return features.map((f) => f.getId());
   }
 
   /**
@@ -501,8 +542,7 @@ class Vector extends FeatureLayer {
    */
   getFeaturesById(ids) {
     check(ids, [[String, Number]]);
-    return ids.map(id => this.getFeatureById(id))
-      .filter(f => f != null);
+    return ids.map((id) => this.getFeatureById(id)).filter((f) => f != null);
   }
 
   /**
@@ -538,7 +578,7 @@ class Vector extends FeatureLayer {
       return metaExtent;
     }
     const extent = new Extent({
-      ...mercatorProjection.toJSON(),
+      projection: mercatorProjection.toJSON(),
       coordinates: this.source.getExtent(),
     });
     if (extent.isValid()) {
@@ -562,20 +602,12 @@ class Vector extends FeatureLayer {
     return null;
   }
 
-  /**
-   * @param {VectorClickedObject} object
-   * @returns {?GenericFeature}
-   */
-  getGenericFeatureFromClickedObject(object) {
-    return getGenericFeatureFromClickedObject(object, this);
-  }
-
   /**
    * @returns {VectorOptions}
    */
   toJSON() {
     const config = /** @type {VectorOptions} */ (super.toJSON());
-    const defaultOptions = Vector.getDefaultOptions();
+    const defaultOptions = VectorLayer.getDefaultOptions();
 
     if (this.projection.epsg !== getDefaultProjection().epsg) {
       config.projection = this.projection.toJSON();
@@ -589,14 +621,14 @@ class Vector extends FeatureLayer {
       config.minResolution = this.minResolution;
     }
 
-    if (this.dontUseTerrainForOblique !== defaultOptions.dontUseTerrainForOblique) {
+    if (
+      this.dontUseTerrainForOblique !== defaultOptions.dontUseTerrainForOblique
+    ) {
       config.dontUseTerrainForOblique = this.dontUseTerrainForOblique;
     }
 
     if (this.highlightStyle) {
-      config.highlightStyle = this.highlightStyle[referenceableStyleSymbol] ?
-        this.highlightStyle.getReference() :
-        this.highlightStyle.getOptions();
+      config.highlightStyle = this.highlightStyle.toJSON();
     }
 
     if (this.isDynamic !== defaultOptions.isDynamic) {
@@ -608,8 +640,6 @@ class Vector extends FeatureLayer {
       config.vectorProperties = vectorPropertiesConfig;
     }
 
-    // XXX missing style
-
     return config;
   }
 
@@ -628,5 +658,5 @@ class Vector extends FeatureLayer {
   }
 }
 
-VcsClassRegistry.registerClass(Vector.className, Vector);
-export default Vector;
+layerClassRegistry.registerClass(VectorLayer.className, VectorLayer);
+export default VectorLayer;