@vcmap/core 5.0.0-rc.0

package/src/vcs/vcm/util/exclusiveManager.js

@@ -0,0 +1,135 @@
+/**
+ * Tracks layer exclusivity, added to every {@link LayerCollection}.
+ * @class
+ * @api
+ */
+class ExclusiveManager {
+  constructor() {
+    /**
+     * The layers managed by this manager. The key is the group.
+     * @type {Map<(string|symbol), Set<import("@vcmap/core").Layer>>}
+     * @api
+     */
+    this.layers = new Map();
+  }
+
+  /**
+   * registers a Layer as Exclusive, the activation of a layer triggers the deactivation of all other exclusive Layers.
+   * The layer collection adds exclusive layers to the manager on adding the layer to the collection.
+   * @param {import("@vcmap/core").Layer} layer - layer to register
+   * @api
+   */
+  registerLayer(layer) {
+    const { exclusiveGroups } = layer;
+    if (exclusiveGroups.length > 0) {
+      exclusiveGroups.forEach((group) => {
+        if (!this.layers.has(group)) {
+          this.layers.set(group, new Set());
+        }
+        const groupSet = this.layers.get(group);
+        groupSet.add(layer);
+      });
+
+      if (layer.active) {
+        this.handleLayerActivated(layer);
+      }
+    }
+  }
+
+  /**
+   * Removes a layer from tracking. Layer collections remove the layer once they are removed from them.
+   * @param {import("@vcmap/core").Layer} layer - layer to unregister
+   * @api
+   */
+  unregisterLayer(layer) {
+    const { exclusiveGroups } = layer;
+    if (exclusiveGroups.length > 0) {
+      exclusiveGroups.forEach((group) => {
+        this.layers.get(group).delete(layer);
+      });
+    }
+  }
+
+  /**
+   * @param {import("@vcmap/core").Layer} layer
+   */
+  handleSplitDirectionChanged(layer) {
+    if (layer.active) {
+      this.handleLayerActivated(layer);
+    }
+  }
+
+  /**
+   * handles the changing of a layer
+   * @param {import("@vcmap/core").Layer} layer
+   */
+  handleLayerActivated(layer) {
+    const { exclusiveGroups } = layer;
+    if (exclusiveGroups.length > 0) {
+      const splitDirection = /** @type {SplitLayer} */ (layer).splitDirection || 0;
+      exclusiveGroups.forEach((group) => {
+        if (this.layers.has(group)) {
+          this.layers.get(group).forEach((groupLayer) => {
+            if (
+              groupLayer !== layer && !(
+                splitDirection &&
+                /** @type {SplitLayer} */ (groupLayer).splitDirection &&
+                /** @type {SplitLayer} */ (groupLayer).splitDirection !== splitDirection
+              )
+            ) {
+              groupLayer.deactivate();
+            }
+          });
+        }
+      });
+    }
+  }
+
+  /**
+   * @param {import("@vcmap/core").Layer} layer
+   */
+  handleExclusiveGroupsChanged(layer) {
+    [...this.layers.values()].forEach((set) => {
+      set.delete(layer);
+    });
+    this.registerLayer(layer);
+  }
+
+  /**
+   * Gets all layers in the given group
+   * @param {string} group
+   * @returns {Array<import("@vcmap/core").Layer>}
+   * @api
+   */
+  getActiveLayersForGroup(group) {
+    const layerGroup = this.layers.get(group);
+    if (layerGroup) {
+      const activeLayers = [];
+      layerGroup.forEach((groupLayer) => {
+        if (groupLayer.active) {
+          activeLayers.push(groupLayer);
+        }
+      });
+      return activeLayers;
+    }
+    return [];
+  }
+
+  /**
+   * Clears all layer groups
+   * @api
+   */
+  clear() {
+    this.layers.clear();
+  }
+
+  /**
+   * Destroys the ExclusiveManager
+   * @api
+   */
+  destroy() {
+    this.clear();
+  }
+}
+
+export default ExclusiveManager;

package/src/vcs/vcm/util/extent.js

@@ -0,0 +1,124 @@
+import Projection from './projection.js';
+
+/**
+ * @typedef {ProjectionOptions} ExtentOptions
+ * @property {import("ol/extent").Extent|undefined} coordinates - if not specified, the extent of the projection is used
+ * @api
+ */
+
+/**
+ * checks extent validity, point extent is also valid
+ * @param {import("ol/extent").Extent} extent
+ * @returns {boolean}
+ */
+function checkExtentValidity(extent) {
+  if (!extent || !Array.isArray(extent) || extent.length !== 4) {
+    return false;
+  }
+
+  if (
+    !Number.isFinite(extent[0]) ||
+    !Number.isFinite(extent[1]) ||
+    !Number.isFinite(extent[2]) ||
+    !Number.isFinite(extent[3])
+  ) {
+    return false;
+  }
+  return extent[0] <= extent[2] && extent[1] <= extent[3];
+}
+
+
+/**
+ * Extent Class
+ * @class
+ * @export
+ * @api
+ */
+class Extent {
+  /**
+   * @param {ExtentOptions=} options object
+   */
+  constructor(options = {}) {
+    /** @type {Projection} */
+    this.projection = new Projection({
+      epsg: options.epsg,
+      proj4: options.proj4,
+      alias: options.alias,
+    });
+
+    /** @type {import("ol/extent").Extent|null} */
+    this.extent = options.coordinates || this.projection.proj.getExtent();
+  }
+
+  /**
+   * @param {Projection} destination
+   * @param {import("ol/extent").Extent=} result
+   * @returns {import("ol/extent").Extent}
+   */
+  getCoordinatesInProjection(destination, result) {
+    if (destination.epsg === this.projection.epsg) { // TODO aliases?!
+      const extent = result ? result.splice(0, 4, ...this.extent) : this.extent.slice();
+      return /** @type {import("ol/extent").Extent} */ (extent);
+    }
+    const transformer = Projection
+      .getTransformer(destination, this.projection);
+    const target = result || [];
+    transformer(this.extent, target, 2);
+    return /** @type {import("ol/extent").Extent} */ (target);
+  }
+
+  /**
+   * only checks for null/nan numbers, does not check for spatial validity of the extent
+   * @returns {boolean} true if extent is valid
+   */
+  isValid() {
+    return checkExtentValidity(this.extent);
+  }
+
+  /**
+   * @returns {ExtentOptions}
+   */
+  getConfigObject() {
+    return { coordinates: this.extent.slice(), ...this.projection.getConfigObject() };
+  }
+
+  /**
+   * @returns {Extent}
+   */
+  clone() {
+    return new Extent(this.getConfigObject());
+  }
+
+  /**
+   * @param {Extent} extent
+   * @returns {boolean}
+   */
+  equals(extent) {
+    if (this === extent) {
+      return true;
+    }
+
+    return this.isValid() &&
+      extent.isValid() &&
+      this.extent.every((c, i) => c === extent.extent[i]) &&
+      this.projection.equals(extent.projection);
+  }
+
+  /**
+   * validates extent options, checks for valid projection and the geometry of the given coordinates.
+   * The Coordinate extent is also valid if its a point extent
+   * @param {ExtentOptions} options
+   * @returns {boolean}
+   * @api
+   */
+  static validateOptions(options) {
+    return Projection.validateOptions(options) && checkExtentValidity(options.coordinates);
+  }
+
+  /**
+   * @type {import("ol/extent").Extent}
+   */
+  static get WGS_84_EXTENT() { return [-180, -90, 180, 90]; }
+}
+
+export default Extent;

package/src/vcs/vcm/util/featureProvider/abstractFeatureProvider.js

@@ -0,0 +1,196 @@
+import { v4 as uuidv4 } from 'uuid';
+import { parseBoolean } from '@vcsuite/parsers';
+import { vcsLayerName } from '../../layer/layerSymbols.js';
+import VcsObject from '../../object.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';
+
+/**
+ * @namespace featureProvider
+ */
+
+/**
+ * @typedef {VcsObjectOptions} AbstractFeatureProviderOptions
+ * @property {import("@vcmap/core").StyleItemOptions|import("@vcmap/core").StyleItem|undefined} style - the style to apply to features created by this feature provider
+ * @property {Object|undefined} genericFeatureProperties - generic properties to add to features created by this feature provider
+ * @property {import("@vcmap/core").VectorProperties|import("@vcmap/core").VectorPropertiesOptions|undefined} vectorProperties - the vector properties of the features. Allow picking is false by default.
+ * @property {boolean} [showGeometry=false] - show the resulting geometry in the map
+ * @property {Array<string>} [mapTypes=[]] - can be used to constrict the featureProvider to specific mapTypes empty array means no restriction
+ */
+
+/**
+ * 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.
+ * @class
+ * @export
+ * @abstract
+ * @api
+ */
+class AbstractFeatureProvider extends VcsObject {
+  static get className() { return 'vcs.vcm.util.featureProvider.AbstractFeatureProvider'; }
+
+  /**
+   * @returns {AbstractFeatureProviderOptions}
+   */
+  static getDefaultOptions() {
+    return {
+      vectorProperties: {
+        allowPicking: false,
+      },
+      genericFeatureProperties: undefined,
+      showGeometry: false,
+      mapTypes: [],
+    };
+  }
+
+  /**
+   * @param {string} layerName
+   * @param {AbstractFeatureProviderOptions} options
+   */
+  constructor(layerName, options) {
+    super(options);
+    const defaultOptions = AbstractFeatureProvider.getDefaultOptions();
+    /**
+     * The layer name of the associated layer
+     * @api
+     * @type {string}
+     */
+    this.layerName = layerName;
+    /**
+     * The style set on features created by this provider
+     * @type {import("@vcmap/core").StyleItem|undefined}
+     * @api
+     */
+    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);
+    /**
+     * 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 });
+    /**
+     * An object of potential generic feature properties to add to all feature created by this provider
+     * @type {Object<string, *>|undefined}
+     * @api
+     */
+    this.genericFeatureProperties = options.genericFeatureProperties || defaultOptions.genericFeatureProperties;
+
+    /**
+     * 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;
+  }
+
+  /**
+   * checks if the featureProvider is supported for provided Map
+   * @param {import("@vcmap/core").VcsMap} map
+   * @returns {boolean}
+   * @api stable
+   */
+  isSupported(map) {
+    return map &&
+      (this.mapTypes.length === 0 || this.mapTypes.includes(map.className));
+  }
+
+  /**
+   * Ensures the feature has an ID, applies all vectorProperties and adds the generic properties, style and the vcsLayerName
+   * and isProvidedFeature symbols to the feature
+   * @param {import("ol").Feature<import("ol/geom/Geometry").default>} feature
+   * @returns {import("ol").Feature<import("ol/geom/Geometry").default>}
+   * @api
+   */
+  getProviderFeature(feature) {
+    if (!feature.getId()) {
+      feature.setId(uuidv4());
+    }
+    if (this.style) {
+      feature.setStyle(this.style.style);
+    }
+    if (this.genericFeatureProperties) {
+      feature.setProperties(this.genericFeatureProperties);
+    }
+    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);
+      }
+    });
+    return feature;
+  }
+
+  /**
+   * This method must be overwritten by any implementations. Before returning the array of features, be sure to use the getProviderFeature
+   * on each feature to ensure all properties and symbols required by the VCM architecture
+   * to handle your feature is called: (e.g. <code>return features.map(f => this.getProviderFeature(f)</code>);
+   * @param {import("ol/coordinate").Coordinate} coordinate - in mercator
+   * @param {number} resolution - meters per pixel for the given location
+   * @returns {Promise<Array<import("ol").Feature<import("ol/geom/Geometry").default>>>}
+   * @api
+   */
+  // eslint-disable-next-line no-unused-vars,class-methods-use-this
+  async getFeaturesByCoordinate(coordinate, resolution) {
+    return [];
+  }
+
+  /**
+   * Returns the object required to configure this feature provider.
+   * @returns {AbstractFeatureProviderOptions}
+   * @api
+   */
+  getConfigObject() {
+    const config =
+      /** @type {AbstractFeatureProviderOptions} */ (super.getConfigObject());
+
+    const defaultOptions = AbstractFeatureProvider.getDefaultOptions();
+    delete config.name; // the name is irrelevant, since its the layers name
+
+    if (this.showGeometry !== defaultOptions.showGeometry) {
+      config.showGeometry = this.showGeometry;
+    }
+
+    if (this.genericFeatureProperties) {
+      config.genericFeatureProperties = { ...this.genericFeatureProperties };
+    }
+
+    if (this.style) {
+      config.style = this.style.getOptions();
+    }
+
+    const vectorPropertiesConfig = this.vectorProperties
+      .getVcsMeta({ ...VectorProperties.getDefaultOptions(), ...defaultOptions.vectorProperties });
+    if (Object.keys(vectorPropertiesConfig).length > 0) {
+      config.vectorProperties = vectorPropertiesConfig;
+    }
+    return config;
+  }
+
+  /**
+   * Destroys this feature provider and detaches its resources
+   * @inheritDoc
+   */
+  destroy() {
+    this.style = null;
+    this.vectorProperties.destroy();
+    this.genericFeatureProperties = undefined;
+    super.destroy();
+  }
+}
+
+export default AbstractFeatureProvider;

package/src/vcs/vcm/util/featureProvider/featureProviderHelpers.js

@@ -0,0 +1,51 @@
+import { getCenter } from 'ol/extent.js';
+import Projection from '../projection.js';
+import { createOrUpdateFromGeometry } from '../featureconverter/extent3d.js';
+
+/**
+ * @param {VectorClickedObject} feature
+ * @param {import("@vcmap/core").Layer} layer
+ * @returns {?GenericFeature}
+ */
+// eslint-disable-next-line import/prefer-default-export
+export function getGenericFeatureFromProvidedFeature(feature, layer) {
+  const attributes = feature.getProperties();
+  delete attributes[feature.getGeometryName()];
+
+  let { clickedPosition } = feature;
+  const geometry = feature.getGeometry();
+  const isModel = feature.get('olcs_modelUrl');
+  if (
+    geometry &&
+    (
+      (geometry.getType() === 'Point' && !isModel) ||
+      (clickedPosition && !clickedPosition.exactPosition) ||
+      (!clickedPosition && geometry)
+    )
+  ) {
+    const center = getCenter(geometry.getExtent());
+    if (center) {
+      Projection.mercatorToWgs84(center, true);
+      clickedPosition = { longitude: center[0], latitude: center[1] };
+    }
+  }
+
+  let heightOffset = clickedPosition.height;
+  if (!isModel) {
+    const extent = createOrUpdateFromGeometry(geometry);
+    const max = Number.isFinite(extent[5]) ? extent[5] : 0;
+    heightOffset = max;
+  }
+  const relativeToGround = !isModel && feature.get('olcs_altitudeMode') === 'relativeToGround';
+
+  delete attributes.clickedPosition;
+  return {
+    layerName: layer.name,
+    layerClass: layer.className,
+    attributes,
+    longitude: clickedPosition.longitude,
+    latitude: clickedPosition.latitude,
+    height: heightOffset,
+    relativeToGround,
+  };
+}

package/src/vcs/vcm/util/featureProvider/featureProviderSymbols.js

@@ -0,0 +1,11 @@
+/**
+ * Added to ol.Feature, if they are not part of a layer, but provided by an {@link AbstractFeatureProvider}.
+ * @type {symbol}
+ */
+export const isProvidedFeature = Symbol('isProvidedFeature');
+
+/**
+ * A boolean value, indicating whether {@link SelectBehavior} should add the feature to the selected item layer
+ * @type {symbol}
+ */
+export const showProvidedFeature = Symbol('showProvidedFeature');

package/src/vcs/vcm/util/featureProvider/tileProviderFeatureProvider.js

@@ -0,0 +1,62 @@
+import AbstractFeatureProvider from './abstractFeatureProvider.js';
+
+
+/**
+ * @typedef {AbstractFeatureProviderOptions} TileProviderFeatureProviderOptions
+ * @property {import("@vcmap/core").TileProvider} tileProvider
+ * @api
+ */
+
+/**
+ * @class
+ * @extends {AbstractFeatureProvider}
+ */
+class TileProviderFeatureProvider extends AbstractFeatureProvider {
+  static get className() { return 'vcs.vcm.util.featureProvider.TileProviderFeatureProvider'; }
+
+  /**
+   * @param {string} layerName
+   * @param {TileProviderFeatureProviderOptions} options
+   */
+  constructor(layerName, options) {
+    super(layerName, options);
+
+    /**
+     * Map ClassNames Can be used to only apply this featureProvider to the specified maps
+     * @type {Array<string>}
+     * @api
+     */
+    this.mapTypes = ['vcs.vcm.maps.Cesium'];
+
+    /**
+     * TileProvider
+     * @type {import("@vcmap/core").TileProvider}
+     * @api
+     */
+    this.tileProvider = options.tileProvider;
+  }
+
+
+  /**
+   * @inheritDoc
+   * @param {import("ol/coordinate").Coordinate} coordinate
+   * @param {number} resolution
+   * @returns {Promise<Array<import("ol").Feature<import("ol/geom/Geometry").default>>>}
+   */
+  async getFeaturesByCoordinate(coordinate, resolution) {
+    const features = await this.tileProvider.getFeaturesByCoordinate(coordinate, resolution);
+    return features.filter((feature) => {
+      return this.vectorProperties.getAllowPicking(feature);
+    });
+  }
+
+  /**
+   * @inheritDoc
+   */
+  destroy() {
+    this.tileProvider = undefined;
+    super.destroy();
+  }
+}
+
+export default TileProviderFeatureProvider;