@vcmap/core 5.0.0-rc.2 → 5.0.0-rc.5

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

@@ -1,8 +1,10 @@
 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
+ * @typedef {Object} ExtentOptions
+ * @property {string} [type]
+ * @property {import("ol/extent").Extent|undefined} [coordinates] - if not specified, the extent of the projection is used
+ * @property {ProjectionOptions} [projection] - if not specified the default projection is assumed
  * @api
  */
 
@@ -35,16 +37,17 @@ function checkExtentValidity(extent) {
  * @api
  */
 class Extent {
+  /**
+   * @type {string}
+   */
+  static get className() { return 'vcs.vcm.util.Extent'; }
+
   /**
    * @param {ExtentOptions=} options object
    */
   constructor(options = {}) {
     /** @type {Projection} */
-    this.projection = new Projection({
-      epsg: options.epsg,
-      proj4: options.proj4,
-      alias: options.alias,
-    });
+    this.projection = new Projection(options.projection);
 
     /** @type {import("ol/extent").Extent|null} */
     this.extent = options.coordinates || this.projection.proj.getExtent();
@@ -79,7 +82,11 @@ class Extent {
    * @returns {ExtentOptions}
    */
   toJSON() {
-    return { coordinates: this.extent.slice(), ...this.projection.toJSON() };
+    return {
+      coordinates: this.extent.slice(),
+      projection: this.projection.toJSON(),
+      type: Extent.className,
+    };
   }
 
   /**
@@ -112,7 +119,7 @@ class Extent {
    * @api
    */
   static validateOptions(options) {
-    return Projection.validateOptions(options) && checkExtentValidity(options.coordinates);
+    return Projection.validateOptions(options.projection || {}) && checkExtentValidity(options.coordinates);
   }
 
   /**

package/src/vcs/vcm/util/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 Extent3D from '../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/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';
@@ -10,6 +9,7 @@ import AbstractFeatureProvider from './abstractFeatureProvider.js';
 import Projection, { mercatorProjection } from '../projection.js';
 import { getWMSSource } from '../../layer/wmsHelpers.js';
 import Extent from '../extent.js';
+import { requestJson } from '../fetch.js';
 
 /**
  * @typedef {AbstractFeatureProviderOptions} WMSFeatureProviderOptions
@@ -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;
 
@@ -211,8 +210,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 [];

package/src/vcs/vcm/util/featureconverter/extent3D.js

@@ -0,0 +1,181 @@
+import GeometryType from 'ol/geom/GeometryType.js';
+import { check } from '@vcsuite/check';
+
+
+class Extent3D {
+  /**
+   * @param {Array<number>} array
+   * @returns {Extent3D}
+   */
+  static fromArray(array) {
+    check(array, [Number]);
+    check(array.length, 6);
+    return new Extent3D(array[0], array[1], array[2], array[3], array[4], array[5]);
+  }
+
+  /**
+   * @param {import("ol/geom").Geometry} geometry
+   * @returns {Extent3D}
+   */
+  static fromGeometry(geometry) {
+    const extent = new Extent3D();
+    extent.extendWithGeometry(geometry);
+    return extent;
+  }
+
+  /**
+   * @param {VectorHeightInfo} heightInfo
+   * @returns {Extent3D}
+   */
+  static fromHeightInfo(heightInfo) {
+    const extent = new Extent3D();
+    extent.extendWithHeightInfo(heightInfo);
+    return extent;
+  }
+
+  /**
+   * @param {number} minX
+   * @param {number} minY
+   * @param {number} minZ
+   * @param {number} maxX
+   * @param {number} maxY
+   * @param {number} maxZ
+   */
+  constructor(minX = Infinity, minY = Infinity, minZ = Infinity, maxX = -Infinity, maxY = -Infinity, maxZ = -Infinity) {
+    /**
+     * @type {number}
+     */
+    this.minX = minX;
+    /**
+     * @type {number}
+     */
+    this.minY = minY;
+    /**
+     * @type {number}
+     */
+    this.minZ = minZ;
+    /**
+     * @type {number}
+     */
+    this.maxX = maxX;
+    /**
+     * @type {number}
+     */
+    this.maxY = maxY;
+    /**
+     * @type {number}
+     */
+    this.maxZ = maxZ;
+  }
+
+  /**
+   * @param {import("ol/geom").Geometry} geometry
+   */
+  extendWithGeometry(geometry) {
+    if (geometry.getType() === GeometryType.GEOMETRY_COLLECTION) {
+      /** @type {import("ol/geom/GeometryCollection").default} */ (geometry)
+        .getGeometriesArray().forEach((geom) => { this.extendWithGeometry(geom); });
+    } else if (geometry.getType() === GeometryType.CIRCLE) {
+      const flatCoordinates = /** @type {import("ol/geom/Circle").default} */ (geometry).getFlatCoordinates();
+      const stride = /** @type {import("ol/geom/Circle").default} */ (geometry).getStride();
+      const radius = flatCoordinates[stride] - flatCoordinates[0];
+      this.extendXY(
+        flatCoordinates[0] - radius,
+        flatCoordinates[1] - radius,
+      );
+      this.extendXY(
+        flatCoordinates[0] + radius,
+        flatCoordinates[1] + radius,
+      );
+      if (stride > 2) {
+        this.extendZ(flatCoordinates[2]);
+      }
+    } else {
+      const flatCoordinates = /** @type {import("ol/geom/SimpleGeometry").default} */ (geometry).getFlatCoordinates();
+      const stride = /** @type {import("ol/geom/SimpleGeometry").default} */ (geometry).getStride();
+      this.extendFlatCoordinates(flatCoordinates, stride);
+    }
+  }
+
+  /**
+   * @param {VectorHeightInfo} heightInfo
+   */
+  extendWithHeightInfo(heightInfo) {
+    if (heightInfo.extruded) {
+      const calculatedFeatureMaxHeight =
+        heightInfo.groundLevel + heightInfo.storeyHeightsAboveGround.reduce((accumulator, currentValue) => {
+          return accumulator + currentValue;
+        }, 0);
+      this.extendZ(calculatedFeatureMaxHeight);
+      const calculatedFeatureMinHeight =
+        heightInfo.groundLevel - heightInfo.storeyHeightsBelowGround.reduce((accumulator, currentValue) => {
+          return accumulator + currentValue;
+        }, 0);
+      this.extendZ(calculatedFeatureMinHeight);
+    }
+  }
+
+  /**
+   * @param {number} x
+   * @param {number} y
+   * @param {number} z
+   */
+  extendXYZ(x, y, z) {
+    this.minX = Math.min(this.minX, x);
+    this.minY = Math.min(this.minY, y);
+    this.minZ = Math.min(this.minZ, z);
+    this.maxX = Math.max(this.maxX, x);
+    this.maxY = Math.max(this.maxY, y);
+    this.maxZ = Math.max(this.maxZ, z);
+  }
+
+  /**
+   * @param {number} x
+   * @param {number} y
+   */
+  extendXY(x, y) {
+    this.minX = Math.min(this.minX, x);
+    this.minY = Math.min(this.minY, y);
+    this.maxX = Math.max(this.maxX, x);
+    this.maxY = Math.max(this.maxY, y);
+  }
+
+  /**
+   * @param {number} z
+   */
+  extendZ(z) {
+    this.minZ = Math.min(this.minZ, z);
+    this.maxZ = Math.max(this.maxZ, z);
+  }
+
+  /**
+   * @param {Array<number>} flatCoordinates
+   * @param {number} stride
+   */
+  extendFlatCoordinates(flatCoordinates, stride) {
+    const { length } = flatCoordinates;
+    for (let offset = 0; offset < length; offset += stride) {
+      if (stride > 2) {
+        this.extendXYZ(flatCoordinates[offset], flatCoordinates[offset + 1], flatCoordinates[offset + 2]);
+      } else {
+        this.extendXY(flatCoordinates[offset], flatCoordinates[offset + 1]);
+      }
+    }
+  }
+
+  /**
+   * @returns {import("ol/extent").Extent}
+   */
+  to2D() {
+    return [this.minX, this.minY, this.maxX, this.maxY];
+  }
+
+  /**
+   * @returns {Array<number>}
+   */
+  toArray() {
+    return [this.minX, this.minY, this.minZ, this.maxX, this.maxY, this.maxZ];
+  }
+}
+
+export default Extent3D;

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

@@ -0,0 +1,32 @@
+/**
+ * @param {string} url
+ * @param {RequestInit=} init
+ * @returns {Promise<Response>}
+ */
+export async function requestUrl(url, init) {
+  const response = await fetch(url, init);
+  if (!response.ok) {
+    throw new Error(`Failed fetching url ${url} with status: ${response.status}`);
+  }
+  return response;
+}
+
+/**
+ * @param {string} url
+ * @param {RequestInit=} init
+ * @returns {Promise<any>}
+ */
+export async function requestJson(url, init) {
+  const response = await requestUrl(url, init);
+  return response.json();
+}
+
+/**
+ * @param {string} url
+ * @param {RequestInit=} init
+ * @returns {Promise<ArrayBuffer>}
+ */
+export async function requestArrayBuffer(url, init) {
+  const response = await requestUrl(url, init);
+  return response.arrayBuffer();
+}

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

@@ -42,8 +42,22 @@ class IndexedCollection extends Collection {
      * @api
      */
     this.moved = new VcsEvent();
+
+    /**
+     * @type {symbol}
+     * @private
+     */
+    this._previousIndexSymbol = Symbol('previousIndex');
   }
 
+  /**
+   * Get the symbol which is attached to an item prior to its removal. If an item is removed, the current index of the item
+   * is set on the item with this symbol.
+   * @type {symbol}
+   * @readonly
+   */
+  get previousIndexSymbol() { return this._previousIndexSymbol; }
+
   /**
    * Returns an item at index.
    * @param {number} index
@@ -76,6 +90,15 @@ class IndexedCollection extends Collection {
     return null;
   }
 
+  /**
+   * @inheritDoc
+   * @param {T} item
+   */
+  remove(item) {
+    item[this._previousIndexSymbol] = this._array.indexOf(item);
+    super.remove(item);
+  }
+
   /**
    * @param {T} item
    * @param {number} itemIndex

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

@@ -44,9 +44,6 @@ class LayerCollection extends IndexedCollection {
     this._layerEventListeners = {};
 
     /**
-     * A symbol to describe the local z index of a layer. The local z index must not equal the layers z index, but is
-     * always consistent in comparison to the neighbouring layers. If a layer is moved other then by z index, the collection
-     * ensures consistency by setting a new local z index if needed.
      * @type {symbol}
      * @private
      */
@@ -67,6 +64,15 @@ class LayerCollection extends IndexedCollection {
     this.exclusiveManager = new ExclusiveManager();
   }
 
+  /**
+   * A symbol to describe the local z index of a layer. The local z index must not equal the layers z index, but is
+   * always consistent in comparison to the neighbouring layers. If a layer is moved other then by z index, the collection
+   * ensures consistency by setting a new local z index if needed.
+   * @type {symbol}
+   * @readonly
+   */
+  get zIndexSymbol() { return this._zIndexSymbol; }
+
   /**
    * @param {import("@vcmap/core").Layer} layer
    * @private
@@ -116,10 +122,9 @@ class LayerCollection extends IndexedCollection {
   _zIndexChanged(layer) {
     const currentIndex = this.indexOf(layer);
     if (currentIndex > -1) {
-      const increased = layer[this._zIndexSymbol] < layer.zIndex;
       layer[this._zIndexSymbol] = layer.zIndex;
       let zIndexPosition = this._findZIndexPosition(layer.zIndex);
-      if (increased && zIndexPosition > 0) {
+      if (zIndexPosition > 0 && zIndexPosition > currentIndex) {
         zIndexPosition -= 1; // remove self from count
       }
       zIndexPosition = zIndexPosition != null ? zIndexPosition : this._array.length - 1;

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

@@ -0,0 +1,224 @@
+/* eslint no-underscore-dangle: ["error", { "allow": ["_array"] }] */
+// eslint-disable-next-line max-classes-per-file
+import { check } from '@vcsuite/check';
+import { getLogger as getLoggerByName } from '@vcsuite/logger';
+import { contextIdSymbol } from '../vcsAppContextHelpers.js';
+import Collection from './collection.js';
+import VcsEvent from '../event/vcsEvent.js';
+
+/**
+ * @returns {import("@vcsuite/logger").Logger}
+ */
+function getLogger() {
+  return getLoggerByName('OverrideCollection');
+}
+
+/**
+ * The override collection adds the ability to override a unique item and re-creating it, should the override
+ * be removed. This does change some flow of called events. 1) if you override an item, removed is not called for the
+ * removed current item. 2) added can be called more the once for the same unique id. 3) replaced is called for items
+ * which where replaced. replaced is called after added has been called for the item.
+ * @interface OverrideCollectionInterface
+ * @property {import("@vcmap/core").VcsEvent<T>} replaced - replaced is called after added
+ * @property {function(T):T|null} override - returns the overriden item or null if the item could not be inserted (this would be the result of a race condition)
+ * @property {Map<string, Array<Object>>} shadowMap
+ * @property {function(Array<Object>, string):Promise<void>} parseItems
+ * @property {function(string):Promise<void>} removeContext
+ * @property {function(string):Array<Object>} serializeContext
+ * @template {*} T
+ */
+
+/**
+ * A symbol added to override collections.
+ * @type {symbol}
+ */
+export const isOverrideCollection = Symbol('OverrideCollection');
+
+/**
+ * @param {Collection<T>} collection
+ * @param {function():string} getDynamicContextId - function to get the current dynamic context id
+ * @param {(function(T):Object)=} serializeItem - optional function to serialize an item, defaults to returning item.toJSON or item: i => (i.toJSON || i)
+ * @param {(function(Object):(T|Promise<T>))=} deserializeItem - optional desirialization function. defaults to returning the passed object: i => i
+ * @param {*=} ctor - optional constructor to validate deserialized items against. if passed, deserializeItem must be an instance of ctor.
+ * @param {(function(T, (T|null|undefined), (number|undefined)):number|null)=} determineShadowIndex - return the index where a shadow should be inserted. only has relevance, if the collection is indexed. previous and current index may be null.
+ * @template {*} T
+ * @returns {OverrideCollection<T>}
+ */
+function makeOverrideCollection(
+  collection,
+  getDynamicContextId,
+  serializeItem,
+  deserializeItem,
+  ctor,
+  determineShadowIndex,
+) {
+  check(collection, Collection);
+
+  const overrideCollection = /** @type {OverrideCollection<T>} */ (collection);
+  if (overrideCollection[isOverrideCollection]) {
+    throw new Error('Cannot transform collection, collection already is an OverrideCollection');
+  }
+  overrideCollection[isOverrideCollection] = true;
+
+  const deserialize = deserializeItem || (i => i);
+  // @ts-ignore
+  const serialize = serializeItem || (i => (i.toJSON ? i.toJSON() : i));
+  const getShadowIndex = determineShadowIndex || ((item, shadow, currentIndex) => currentIndex);
+
+  /**
+   * @type {Map<string, Array<Object>>}
+   */
+  overrideCollection.shadowMap = new Map();
+
+  /**
+   * @param {T} item
+   * @returns {T|null}
+   */
+  overrideCollection.override = function override(item) {
+    let shadow;
+    let index;
+    const itemId = item[overrideCollection.uniqueKey];
+
+    if (overrideCollection.hasKey(itemId)) {
+      shadow = overrideCollection.getByKey(itemId);
+      // @ts-ignore
+      index = overrideCollection._array.indexOf(shadow); // faking remove to not call removed
+      if (index > -1) {
+        // @ts-ignore
+        overrideCollection._array.splice(index, 1);
+      }
+      if (!overrideCollection.shadowMap.has(itemId)) {
+        overrideCollection.shadowMap.set(itemId, []);
+      }
+      const shadowsArray = overrideCollection.shadowMap.get(itemId);
+      const serializedShadow = serialize(shadow);
+      // @ts-ignore
+      if (shadow.destroy) {
+        // @ts-ignore
+        shadow.destroy();
+      }
+      serializedShadow[contextIdSymbol] = shadow[contextIdSymbol];
+      shadowsArray.push(serializedShadow);
+    }
+
+    const usedIndex = shadow ? getShadowIndex(shadow, item, index) : null;
+    // @ts-ignore
+    if (overrideCollection.add(item, usedIndex) >= 0) {
+      if (shadow) {
+        overrideCollection.replaced.raiseEvent(item);
+      }
+      return item;
+    }
+    return null;
+  };
+
+  /**
+   * @param {Array<Object>} configArray
+   * @param {string} contextId
+   * @returns {Promise<void>}
+   */
+  overrideCollection.parseItems = async function parseItems(configArray, contextId) {
+    if (Array.isArray(configArray)) {
+      const instanceArray = await Promise.all(configArray.map(async (config) => {
+        const item = await deserialize(config);
+        if (!item || (ctor && !(item instanceof ctor))) {
+          getLogger().warning(`Could not load item ${config[overrideCollection.uniqueKey]} of type ${config.type}`);
+          return null;
+        }
+        item[contextIdSymbol] = contextId;
+        return item;
+      }));
+      instanceArray
+        .filter(i => i)
+        .forEach((i) => { overrideCollection.override(i); });
+    }
+  };
+
+  overrideCollection.removed.addEventListener(async (item) => {
+    const itemId = item[overrideCollection.uniqueKey];
+
+    if (overrideCollection.shadowMap.has(itemId)) {
+      const serializedShadow = overrideCollection.shadowMap.get(itemId).pop();
+      if (serializedShadow) {
+        const reincarnation = await deserialize(serializedShadow);
+        reincarnation[contextIdSymbol] = serializedShadow[contextIdSymbol];
+        // @ts-ignore
+        const index = getShadowIndex(reincarnation, item, item[overrideCollection.previousIndexSymbol]);
+        // @ts-ignore
+        overrideCollection.add(reincarnation, index);
+      }
+
+      if (overrideCollection.shadowMap.get(itemId).length === 0) {
+        overrideCollection.shadowMap.delete(itemId);
+      }
+    }
+  });
+
+  overrideCollection.added.addEventListener((item) => {
+    if (!item[contextIdSymbol]) {
+      item[contextIdSymbol] = getDynamicContextId();
+    }
+  });
+
+  /**
+   * @param {string} contextId
+   * @returns {Promise<void>}
+   */
+  overrideCollection.removeContext = async function removeContext(contextId) {
+    overrideCollection.shadowMap.forEach((shadowsArray, name) => {
+      const newShadowsArray = shadowsArray.filter(c => c[contextIdSymbol] !== contextId);
+      if (newShadowsArray.length === 0) {
+        overrideCollection.shadowMap.delete(name);
+      } else if (newShadowsArray.length !== shadowsArray.length) {
+        overrideCollection.shadowMap.set(name, newShadowsArray);
+      }
+    });
+
+    await Promise.all([...overrideCollection]
+      .filter(item => item[contextIdSymbol] === contextId)
+      .map(async (item) => {
+        overrideCollection.remove(item);
+        // @ts-ignore
+        if (item.destroy) {
+          // @ts-ignore
+          item.destroy();
+        }
+      }));
+  };
+
+  /**
+   * @type {VcsEvent<T>}
+   */
+  overrideCollection.replaced = new VcsEvent();
+
+  /**
+   * @param {string} contextId
+   * @returns {Array<Object>}
+   */
+  overrideCollection.serializeContext = function serializeContext(contextId) {
+    return [...overrideCollection]
+      .map((item) => {
+        if (item[contextIdSymbol] === contextId) {
+          return serialize(item);
+        }
+        if (overrideCollection.shadowMap.has(item[overrideCollection.uniqueKey])) {
+          return overrideCollection.shadowMap.get(item[overrideCollection.uniqueKey])
+            .find(i => i[contextIdSymbol] === contextId);
+        }
+        return null;
+      })
+      .filter(i => i);
+  };
+
+  const originalDestroy = overrideCollection.destroy.bind(overrideCollection);
+
+  overrideCollection.destroy = function destroy() {
+    originalDestroy();
+    overrideCollection.shadowMap.clear();
+    overrideCollection.replaced.destroy();
+  };
+
+  return overrideCollection;
+}
+
+export default makeOverrideCollection;