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

package/src/{vcs/vcm/layer/dataSource.js → layer/dataSourceLayer.js}

@@ -1,74 +1,53 @@
-import { EntityCollection } from '@vcmap/cesium';
+import { EntityCollection } from '@vcmap-cesium/engine';
 import Layer from './layer.js';
-import CesiumMap from '../maps/cesium.js';
-import DataSourceCesium from './cesium/dataSourceCesium.js';
+import CesiumMap from '../map/cesiumMap.js';
+import DataSourceCesiumImpl from './cesium/dataSourceCesiumImpl.js';
 import { vcsLayerName } from './layerSymbols.js';
-import FeatureVisibility, { FeatureVisibilityAction } from './featureVisibility.js';
-import { getGlobalHider } from './globalHider.js';
-import { VcsClassRegistry } from '../classRegistry.js';
-
-/**
- * @typedef {LayerOptions} DataSourceOptions
- * @property {Object|undefined} genericFeatureProperties
- * @api
- */
+import FeatureVisibility, {
+  FeatureVisibilityAction,
+} from './featureVisibility.js';
+import { layerClassRegistry } from '../classRegistry.js';
 
 /**
  * @typedef {Object} DataSourcePickedObject
- * @property {import("@vcmap/cesium").Entity} id
+ * @property {import("@vcmap-cesium/engine").Entity} id
  * @property {ClickPosition} clickedPosition
  * @property {Object} attributes
  */
 
 /**
  * @typedef {LayerImplementationOptions} DataSourceImplementationOptions
- * @property {import("@vcmap/cesium").EntityCollection} entities
- * @property {import("@vcmap/cesium").DataSourceClock|undefined} clock
+ * @property {import("@vcmap-cesium/engine").EntityCollection} entities
+ * @property {import("@vcmap-cesium/engine").DataSourceClock|undefined} clock
  * @api
  */
 
 /**
  * Represents a layer of Cesium.Entity
  * @class
- * @export
  * @extends {Layer}
  * @api stable
  */
-class DataSource extends Layer {
-  static get className() { return 'vcs.vcm.layer.DataSource'; }
-
-  /**
-   * @returns {DataSourceOptions}
-   */
-  static getDefaultOptions() {
-    return {
-      ...Layer.getDefaultOptions(),
-      genericFeatureProperties: {},
-    };
+class DataSourceLayer extends Layer {
+  static get className() {
+    return 'DataSourceLayer';
   }
 
   /**
-   * @param {DataSourceOptions} options
+   * @param {LayerOptions} options
    */
   constructor(options) {
     super(options);
-    const defaultOptions = DataSource.getDefaultOptions();
     /**
      * The entities of this layer. Use the `addEntity` API to add Enitities to ensure interoperability with vcm interfaces
-     * @type {import("@vcmap/cesium").EntityCollection}
+     * @type {import("@vcmap-cesium/engine").EntityCollection}
      * @api
      */
     this.entities = new EntityCollection();
     /**
-     * @type {import("@vcmap/cesium").DataSourceClock|undefined}
+     * @type {import("@vcmap-cesium/engine").DataSourceClock|undefined}
      */
     this.clock = undefined;
-    /**
-     * @type {Object}
-     * @private
-     */
-    this._genericFeatureProperties = options.genericFeatureProperties || defaultOptions.genericFeatureProperties;
-
     /**
      * The feature visibility of this layer. NOTE: Entities cannot be highlighted at this moment.
      * @type {FeatureVisibility}
@@ -81,9 +60,15 @@ class DataSource extends Layer {
      */
     this._featureVisibilityListeners = [];
 
-    this._supportedMaps = [
-      CesiumMap.className,
-    ];
+    this._supportedMaps = [CesiumMap.className];
+  }
+
+  /**
+   * @param {import("@vcmap/core").GlobalHider} globalHider
+   */
+  setGlobalHider(globalHider) {
+    super.setGlobalHider(globalHider);
+    this._setUpFeatureVisibility();
   }
 
   /**
@@ -91,7 +76,10 @@ class DataSource extends Layer {
    * @private
    */
   _setUpFeatureVisibility() {
-    const globalHider = getGlobalHider();
+    this._featureVisibilityListeners.forEach((cb) => {
+      cb();
+    });
+
     this._featureVisibilityListeners = [
       this.featureVisibility.changed.addEventListener(({ action, ids }) => {
         if (action === FeatureVisibilityAction.HIDE) {
@@ -103,28 +91,32 @@ class DataSource extends Layer {
           });
         } // highlight is _possible_ but very tricky with all the possible entity values with potential materials
       }),
-      globalHider.changed.addEventListener(({ action, ids }) => {
-        if (action === FeatureVisibilityAction.HIDE) {
-          ids.forEach((id) => {
-            const entity = this.entities.getById(id);
-            if (entity) {
-              globalHider.addFeature(id, entity);
-            }
-          });
-        }
-      }),
       this.entities.collectionChanged.addEventListener((c, added) => {
         added.forEach((entity) => {
           if (this.featureVisibility.hiddenObjects[entity.id]) {
             this.featureVisibility.addHiddenFeature(entity.id, entity);
           }
-
-          if (globalHider.hiddenObjects[entity.id]) {
-            globalHider.addFeature(entity.id, entity);
+          if (this.globalHider && this.globalHider.hiddenObjects[entity.id]) {
+            this.globalHider.addFeature(entity.id, entity);
           }
         });
       }),
     ];
+
+    if (this.globalHider) {
+      this._featureVisibilityListeners.push(
+        this.globalHider.changed.addEventListener(({ action, ids }) => {
+          if (action === FeatureVisibilityAction.HIDE) {
+            ids.forEach((id) => {
+              const entity = this.entities.getById(id);
+              if (entity) {
+                this.globalHider.addFeature(id, entity);
+              }
+            });
+          }
+        }),
+      );
+    }
   }
 
   /**
@@ -151,18 +143,18 @@ class DataSource extends Layer {
 
   /**
    * @param {CesiumMap} map
-   * @returns {Array<DataSourceCesium>}
+   * @returns {Array<DataSourceCesiumImpl>}
    */
   createImplementationsForMap(map) {
     if (map instanceof CesiumMap) {
-      return [new DataSourceCesium(map, this.getImplementationOptions())];
+      return [new DataSourceCesiumImpl(map, this.getImplementationOptions())];
     }
     return [];
   }
 
   /**
    * adds an entity
-   * @param {import("@vcmap/cesium").Entity.ConstructorOptions|import("@vcmap/cesium").Entity} options - Cesium Entity options or the entity
+   * @param {import("@vcmap-cesium/engine").Entity.ConstructorOptions|import("@vcmap-cesium/engine").Entity} options - Cesium Entity options or the entity
    * @param {?Object=} attributes - a set of properties, typically used for rendering a balloon
    * @param {boolean=} allowPicking - whether to override the layers allowPicking setting for this entity
    * @returns {null|string} the entities id
@@ -183,7 +175,7 @@ class DataSource extends Layer {
    */
   flyToEntity(id) {
     this.getImplementations().forEach((impl) => {
-      /** @type {DataSourceCesium} */ (impl).flyToEntity(id);
+      /** @type {DataSourceCesiumImpl} */ (impl).flyToEntity(id);
     });
   }
 
@@ -214,46 +206,19 @@ class DataSource extends Layer {
     return null;
   }
 
-  /**
-   * @param {DataSourcePickedObject} object
-   * @returns {GenericFeature}
-   */
-  getGenericFeatureFromClickedObject(object) {
-    const attributes = { ...this._genericFeatureProperties, ...object.attributes || {} };
-    return {
-      layerName: this.name,
-      layerClass: this.className,
-      attributes,
-      longitude: object.clickedPosition.longitude,
-      latitude: object.clickedPosition.latitude,
-      height: object.clickedPosition.height,
-      relativeToGround: false,
-    };
-  }
-
-  /**
-   * @inheritDoc
-   * @returns {DataSourceOptions}
-   */
-  toJSON() {
-    const config = /** @type {DataSourceOptions} */ (super.toJSON());
-    if (Object.keys(this._genericFeatureProperties).length > 0) {
-      config.genericFeatureProperties = { ...this._genericFeatureProperties };
-    }
-    return config;
-  }
-
   /**
    * @inheritDoc
    */
   destroy() {
     this.entities.removeAll();
-    this._featureVisibilityListeners.forEach((cb) => { cb(); });
+    this._featureVisibilityListeners.forEach((cb) => {
+      cb();
+    });
     this._featureVisibilityListeners = [];
     this.featureVisibility.destroy();
     super.destroy();
   }
 }
 
-VcsClassRegistry.registerClass(DataSource.className, DataSource);
-export default DataSource;
+layerClassRegistry.registerClass(DataSourceLayer.className, DataSourceLayer);
+export default DataSourceLayer;

package/src/{vcs/vcm/layer → layer}/featureLayer.js

@@ -2,27 +2,28 @@ import Style from 'ol/style/Style.js';
 
 import { check } from '@vcsuite/check';
 import { parseInteger } from '@vcsuite/parsers';
+import { SplitDirection } from '@vcmap-cesium/engine';
 import Layer from './layer.js';
-import StyleItem, { referenceableStyleSymbol } from '../util/style/styleItem.js';
-import VectorStyleItem from '../util/style/vectorStyleItem.js';
+import StyleItem from '../style/styleItem.js';
+import VectorStyleItem from '../style/vectorStyleItem.js';
 import FeatureVisibility from './featureVisibility.js';
-import { getStyleOrDefaultStyle } from '../util/style/styleFactory.js';
-import VcsEvent from '../event/vcsEvent.js';
-import { styleCollection } from '../globalCollections.js';
-import { VcsClassRegistry } from '../classRegistry.js';
+import { getStyleOrDefaultStyle } from '../style/styleFactory.js';
+import VcsEvent from '../vcsEvent.js';
+import { layerClassRegistry } from '../classRegistry.js';
 
 /**
  * @typedef {LayerOptions} FeatureLayerOptions
- * @property {DeclarativeStyleItemOptions|VectorStyleItemOptions|import("@vcmap/core").StyleItem|string|undefined} style
- * @property {string|undefined} activeStyleName - vcs:undocumented
- * @property {Object|undefined} genericFeatureProperties - properties to add to generic features, eg for display in the balloon
+ * @property {DeclarativeStyleItemOptions|VectorStyleItemOptions|import("@vcmap/core").StyleItem|undefined} style
  * @property {number} [balloonHeightOffset=10]
+ * @property {string|undefined} splitDirection - either 'left' or 'right', if omitted none is applied (for 3D Vector currently only Models are split-able)
  * @property {FeatureVisibility|undefined} featureVisibility - vcs:undocumented
  * @api
  */
 
 /**
  * @typedef {LayerImplementationOptions} FeatureLayerImplementationOptions
+ * @property {import("@vcmap/core").GlobalHider} globalHider
+ * @property {import("@vcmap-cesium/engine").SplitDirection} splitDirection
  * @property {FeatureVisibility} featureVisibility
  * @property {import("@vcmap/core").StyleItem} style
  * @api
@@ -39,19 +40,22 @@ import { VcsClassRegistry } from '../classRegistry.js';
 /**
  * @typedef {import("@vcmap/core").LayerImplementation<import("@vcmap/core").VcsMap>} FeatureLayerImplementation
  * @property {function(import("@vcmap/core").StyleItem, boolean=):void} updateStyle
+ * @property {function(import("@vcmap-cesium/engine").SplitDirection):void} updateSplitDirection
  */
 
 /**
- * Base class for all layers representing features, e.g. Vector, Buildings, POIs
+ * Base class for all layers representing features, e.g. VectorLayer, Buildings, POIs
  * @class
  * @abstract
  * @extends {Layer}
- * @export
+ * @implements {SplitLayer}
  * @api
  */
 class FeatureLayer extends Layer {
   /** @type {string} */
-  static get className() { return 'vcs.vcm.layer.FeatureLayer'; }
+  static get className() {
+    return 'FeatureLayer';
+  }
 
   /**
    * @returns {FeatureLayerOptions}
@@ -61,7 +65,7 @@ class FeatureLayer extends Layer {
       ...Layer.getDefaultOptions(),
       style: undefined,
       balloonHeightOffset: 10,
-      genericFeatureProperties: {},
+      splitDirection: undefined,
     };
   }
 
@@ -76,7 +80,7 @@ class FeatureLayer extends Layer {
      * @type {import("@vcmap/core").StyleItem}
      * @private
      */
-    this._style = this.getStyleOrDefaultStyle(options.activeStyleName || options.style);
+    this._style = this.getStyleOrDefaultStyle(options.style);
     /**
      * @type {import("@vcmap/core").StyleItem}
      * @private
@@ -88,24 +92,37 @@ class FeatureLayer extends Layer {
      * @api
      */
     this.styleChanged = new VcsEvent();
-    /**
-     * @type {Object}
-     * @private
-     */
-    this._genericFeatureProperties = options.genericFeatureProperties || defaultOptions.genericFeatureProperties;
-
     /**
      * a height offset for rendering of a balloon for a feature of this layer.
      * @type {number}
      * @api
      */
-    this.balloonHeightOffset = parseInteger(options.balloonHeightOffset, defaultOptions.balloonHeightOffset);
+    this.balloonHeightOffset = parseInteger(
+      options.balloonHeightOffset,
+      defaultOptions.balloonHeightOffset,
+    );
+    /** @type {import("@vcmap-cesium/engine").SplitDirection} */
+    this._splitDirection = SplitDirection.NONE;
+
+    if (options.splitDirection) {
+      this._splitDirection =
+        options.splitDirection === 'left'
+          ? SplitDirection.LEFT
+          : SplitDirection.RIGHT;
+    }
 
+    /**
+     * raised if the split direction changes, is passed the split direction as its only argument
+     * @type {VcsEvent<import("@vcmap-cesium/engine").SplitDirection>}
+     * @api
+     */
+    this.splitDirectionChanged = new VcsEvent();
     /**
      * FeatureVisibility tracks the highlighting and hiding of features on this layer
      * @type {FeatureVisibility}
      */
-    this.featureVisibility = options.featureVisibility || new FeatureVisibility();
+    this.featureVisibility =
+      options.featureVisibility || new FeatureVisibility();
   }
 
   /**
@@ -129,12 +146,27 @@ class FeatureLayer extends Layer {
   }
 
   /**
-   * Generic properties to be added to each feature. Use assignGenericFeatureProperties to change them.
-   * @type {Object}
-   * @readonly
+   * @api
+   * The splitDirection to be applied - for 3D vector features currently only working on points with a Model
+   * @type {import("@vcmap-cesium/engine").SplitDirection}
+   */
+  get splitDirection() {
+    return this._splitDirection;
+  }
+
+  /**
+   * @param {import("@vcmap-cesium/engine").SplitDirection} direction
    */
-  get genericFeatureProperties() {
-    return this._genericFeatureProperties;
+  set splitDirection(direction) {
+    if (direction !== this._splitDirection) {
+      this.getImplementations().forEach((impl) => {
+        /** @type {FeatureLayerImplementation} */ (impl).updateSplitDirection(
+          direction,
+        );
+      });
+      this._splitDirection = direction;
+      this.splitDirectionChanged.raiseEvent(this._splitDirection);
+    }
   }
 
   /**
@@ -143,44 +175,33 @@ class FeatureLayer extends Layer {
   getImplementationOptions() {
     return {
       ...super.getImplementationOptions(),
+      globalHider: this.globalHider,
       featureVisibility: this.featureVisibility,
       style: this.style,
+      splitDirection: this.splitDirection,
     };
   }
 
   /**
-   * @param {Object|import("ol").Feature<import("ol/geom/Geometry").default>|import("@vcmap/cesium").Cesium3DTilePointFeature|import("@vcmap/cesium").Cesium3DTileFeature|DataSourcePickedObject} object
-   * @returns {?Object}
+   * @param {import("@vcmap/core").GlobalHider} globalHider
    */
-  // eslint-disable-next-line no-unused-vars,class-methods-use-this
-  objectClickedHandler(object) { // XXX remove after event implementation
-    return null;
+  setGlobalHider(globalHider) {
+    super.setGlobalHider(globalHider);
+    this.forceRedraw();
   }
 
   /**
-   * This is called by the selectBehavior to create generic features from clicked objects
-   * needs to be implemented by each layer which has clickable objects
-   * @param {Object|VectorClickedObject|import("ol").Feature<import("ol/geom/Geometry").default>} object
-   * @returns {GenericFeature}
+   * @param {Object|import("ol").Feature<import("ol/geom/Geometry").default>|import("@vcmap-cesium/engine").Cesium3DTilePointFeature|import("@vcmap-cesium/engine").Cesium3DTileFeature|DataSourcePickedObject} object
+   * @returns {?Object}
    */
-  // eslint-disable-next-line no-unused-vars
-  getGenericFeatureFromClickedObject(object) { // XXX remove after event implementation
-    this.getLogger().warning('This method should be implemented by any specific layers');
+  // eslint-disable-next-line no-unused-vars,class-methods-use-this
+  objectClickedHandler(object) {
+    // XXX remove after event implementation
     return null;
   }
 
   /**
-   * Set properties, which are always added to the generic object, eg. for use in balloons
-   * @param {Object} properties
-   * @api
-   */
-  assignGenericFeatureProperties(properties) {
-    check(properties, Object);
-    Object.assign(this._genericFeatureProperties, properties);
-  }
-
-  /**
-   * @param {(Reference|DeclarativeStyleItemOptions|VectorStyleItemOptions|import("@vcmap/core").StyleItem|string)=} styleOptions
+   * @param {(DeclarativeStyleItemOptions|VectorStyleItemOptions|import("@vcmap/core").StyleItem)=} styleOptions
    * @param {(import("@vcmap/core").VectorStyleItem|import("@vcmap/core").DeclarativeStyleItem)=} defaultStyle
    * @returns {import("@vcmap/core").StyleItem}
    */
@@ -191,30 +212,27 @@ class FeatureLayer extends Layer {
 
   /**
    * Sets the style based on a styleName on a layer
-   * @param {string|import("ol/style/Style").default|import("ol/style/Style").StyleFunction|import("@vcmap/core").StyleItem} style
+   * @param {import("ol/style/Style").default|import("ol/style/Style").StyleFunction|import("@vcmap/core").StyleItem} style
    * @param {boolean=} silent
    * @api
    */
   setStyle(style, silent) {
-    check(style, [Style, StyleItem, Function, String]);
+    check(style, [Style, StyleItem, Function]);
 
-    if (typeof style === 'string') {
-      const styleItem = styleCollection.getByKey(style);
-      if (!styleItem) {
-        this.getLogger().warning(`could not find style with name ${style}`);
-        return;
-      }
-      this._style = styleItem;
-    } else if (style instanceof StyleItem) {
+    if (style instanceof StyleItem) {
       this._style = style;
     } else {
       this._style = new VectorStyleItem({});
-      this._style.style = /** @type {import("ol/style/Style").default} */ (style);
+      this._style.style = /** @type {import("ol/style/Style").default} */ (
+        style
+      );
     }
-    this.getImplementations()
-      .forEach((impl) => {
-        /** @type {FeatureLayerImplementation} */ (impl).updateStyle(this._style, silent);
-      });
+    this.getImplementations().forEach((impl) => {
+      /** @type {FeatureLayerImplementation} */ (impl).updateStyle(
+        this._style,
+        silent,
+      );
+    });
     this.styleChanged.raiseEvent(this._style);
   }
 
@@ -232,15 +250,11 @@ class FeatureLayer extends Layer {
   toJSON() {
     const config = /** @type {FeatureLayerOptions} */ (super.toJSON());
     if (!this.getStyleOrDefaultStyle().equals(this._style)) {
-      if (this._style[referenceableStyleSymbol]) {
-        config.style = this.style.getReference();
-      } else {
-        config.style = this.style.getOptions();
-      }
+      config.style = this.style.toJSON();
     }
-
-    if (Object.keys(this._genericFeatureProperties).length > 0) {
-      config.genericFeatureProperties = { ...this._genericFeatureProperties };
+    if (this._splitDirection !== SplitDirection.NONE) {
+      config.splitDirection =
+        this._splitDirection === SplitDirection.RIGHT ? 'right' : 'left';
     }
     return config;
   }
@@ -253,9 +267,10 @@ class FeatureLayer extends Layer {
       this.featureVisibility.destroy();
     }
     this.styleChanged.destroy();
+    this.splitDirectionChanged.destroy();
     super.destroy();
   }
 }
 
-VcsClassRegistry.registerClass(FeatureLayer.className, FeatureLayer);
+layerClassRegistry.registerClass(FeatureLayer.className, FeatureLayer);
 export default FeatureLayer;