@vcmap/core 5.0.0-rc.8 → 5.0.0

package/src/style/writeStyle.ts

@@ -0,0 +1,41 @@
+import VectorStyleItem, { VectorStyleItemOptions } from './vectorStyleItem.js';
+import DeclarativeStyleItem from './declarativeStyleItem.js';
+import { type VcsMeta, vcsMetaVersion } from '../layer/vectorProperties.js';
+import StyleItem from './styleItem.js';
+
+export function embedIconsInStyle(
+  obj: VectorStyleItemOptions,
+  embeddedIcons?: string[],
+): VectorStyleItemOptions {
+  if (obj.image && obj.image.src && /^data:/.test(obj.image.src)) {
+    if (embeddedIcons) {
+      let index = embeddedIcons.indexOf(obj.image.src);
+      if (index === -1) {
+        embeddedIcons.push(obj.image.src);
+        index = embeddedIcons.length - 1;
+      }
+      obj.image.src = `:${index}`;
+    } else {
+      obj.image = {
+        // XXX is this the correct fallback?
+        radius: 5,
+      };
+    }
+  }
+  return obj;
+}
+
+function writeStyle(
+  style: StyleItem,
+  vcsMeta: VcsMeta = { version: vcsMetaVersion },
+): VcsMeta {
+  // XXX this entire function is not what is to be expected. feature store expects styles as refs to be possible
+  if (style instanceof VectorStyleItem) {
+    vcsMeta.style = embedIconsInStyle(style.toJSON(), vcsMeta.embeddedIcons);
+  } else if (style instanceof DeclarativeStyleItem) {
+    vcsMeta.style = style.toJSON();
+  }
+  return vcsMeta;
+}
+
+export default writeStyle;

package/src/util/clipping/{clippingObject.js → clippingObject.ts}

@@ -1,41 +1,39 @@
 import { v4 as uuidv4 } from 'uuid';
-import { Cesium3DTileset } from '@vcmap/cesium';
+import {
+  Cesium3DTileset,
+  type ClippingPlaneCollection,
+  type CustomDataSource,
+  type Entity,
+  type Globe,
+  type Scene,
+} from '@vcmap-cesium/engine';
 
 import { check } from '@vcsuite/check';
 import { parseBoolean } from '@vcsuite/parsers';
-import { getLogger as getLoggerByName } from '@vcsuite/logger';
+import { getLogger as getLoggerByName, type Logger } from '@vcsuite/logger';
 import CesiumMap from '../../map/cesiumMap.js';
 import VcsEvent from '../../vcsEvent.js';
 import LayerCollection from '../layerCollection.js';
-
-/**
- * @namespace clipping
- * @export
- * @api
- */
-
-/**
- * Object to define an entity which is clipped by this ClippingObject
- * @typedef {Object} ClippingObjectEntityOption
- * @property {string} layerName
- * @property {string} entityId
- * @api
- */
-
-/**
- * @typedef {Object} ClippingObjectOptions
- * @property {Array<string>|undefined} layerNames
- * @property {Array<ClippingObjectEntityOption>|undefined} entities
- * @property {import("@vcmap/cesium").ClippingPlaneCollection|undefined} clippingPlaneCollection
- * @property {boolean} [terrain=false]
- * @property {boolean} [local=false] - if not local, coordinates are expected in ECEF
- * @api
- */
-
-/**
- * @returns {import("@vcsuite/logger").Logger}
- */
-function getLogger() {
+import type FeatureStoreLayer from '../../layer/featureStoreLayer.js';
+import type VcsMap from '../../map/vcsMap.js';
+import type Layer from '../../layer/layer.js';
+
+export type ClippingObjectEntityOption = {
+  layerName: string;
+  entityId: string;
+};
+
+export type ClippingObjectOptions = {
+  layerNames?: string[];
+  entities?: ClippingObjectEntityOption[];
+  clippingPlaneCollection?: ClippingPlaneCollection;
+  terrain?: boolean;
+  local?: boolean;
+};
+
+export type ClippingTarget = Globe | Entity | Cesium3DTileset;
+
+function getLogger(): Logger {
   return getLoggerByName('ClippingObject');
 }
 
@@ -44,111 +42,83 @@ const globeSymbol = Symbol('ClippingObjectGlobe');
 /**
  * The ClippingObject is a container for a Cesium.ClippingPlaneCollection. The container holds information on the
  * targeted Cesium objects, based on layerNames (for [CesiumTilesetLayer]{@link CesiumTilesetLayer}) or
- * layerName and entity id for Cesium.DataSourceLayer which are part of an [DataSourceLayer]{@link DataSource} layer.
+ * layerName and entity id for Cesium.DataSourceLayer which are part of an [DataSourceLayer]{@link DataSourceLayer} layer.
  * Adding a ClippingObject to the [ClippingObjectManager]{@link ClippingObjectManager} applies the
  * objects Cesium.ClippingPlaneCollection where applicable. Once added, changes to the targets of the object are tracked.
  * To update the Cesium.ClippingPlaneCollection or its definitions, you must trigger an update by setting the clippingPlaneCollection
  * property to the new definition.
- * @class
- * @export
- * @api stable
  */
 class ClippingObject {
+  id = uuidv4();
+
   /**
-   * @param {ClippingObjectOptions=} options
+   * The current layerNames. Use add/removeimport("@vcmap/core").Layer to manipulate.
    */
-  constructor(options = {}) {
-    /** @type {string} */
-    this.id = uuidv4();
-
-    /**
-     * The current layerNames. Use add/removeimport("@vcmap/core").Layer to manipulate.
-     * @type {Array<string>}
-     * @readonly
-     * @api
-     */
-    this.layerNames = options.layerNames || [];
+  readonly layerNames: string[];
 
-    /**
-     * The current entities and their respective layerNames. Use add/removeEntity to manipulate
-     * @type {Array<ClippingObjectEntityOption>}
-     * @readonly
-     * @api
-     */
-    this.entities = options.entities || [];
+  /**
+   * Key is a semantic identifier, eg. layerName or layerName-entitiyId, depending on the target. Targets
+   * represent Cesium Object which support the clippingPlanes API
+   */
+  targets: Map<string | symbol, ClippingTarget> = new Map();
+
+  /**
+   * The current entities and their respective layerNames. Use add/removeEntity to manipulate
+   */
+  readonly entities: ClippingObjectEntityOption[];
+
+  private _clippingPlaneCollection: ClippingPlaneCollection | undefined;
+
+  private _terrain: boolean;
+
+  private _local: boolean;
+
+  /**
+   * Event, raised on a change of targets
+   */
+  targetsUpdated = new VcsEvent<void>();
 
-    /**
-     * Key is a semantic identifier, eg. layerName or layerName-entitiyId, depending on the target. Targets
-     * represent Cesium Object which support the clippingPlanes API
-     * @type {Map<(string|symbol), import("@vcmap/cesium").Entity|import("@vcmap/cesium").Cesium3DTileset|import("@vcmap/cesium").Globe>}
-     */
-    this.targets = new Map();
-
-    /**
-     * @type {import("@vcmap/cesium").ClippingPlaneCollection|null}
-     * @private
-     */
-    this._clippingPlaneCollection = options.clippingPlaneCollection || null;
-    /**
-     * @type {boolean}
-     * @private
-     */
+  /**
+   * Event, raised on changes to the clippingPlaneCollection property
+   */
+  clippingPlaneUpdated = new VcsEvent<void>();
+
+  private _cachedFeatureStoreLayers: Set<FeatureStoreLayer> = new Set();
+
+  private _activeMap: VcsMap | null = null;
+
+  private _layerCollection: LayerCollection | null = null;
+
+  constructor(options: ClippingObjectOptions = {}) {
+    this.layerNames = options.layerNames || [];
+    this.entities = options.entities || [];
+    this._clippingPlaneCollection = options.clippingPlaneCollection;
     this._terrain = parseBoolean(options.terrain, false);
-    /**
-     * @type {boolean}
-     * @private
-     */
     this._local = parseBoolean(options.local, false);
-
-    /**
-     * Event, raised on a change of targets
-     * @type {VcsEvent<void>}
-     * @api
-     */
-    this.targetsUpdated = new VcsEvent();
-
-    /**
-     * Event, raised on changes to the clippingPlaneCollection property
-     * @type {VcsEvent<void>}
-     * @api
-     */
-    this.clippingPlaneUpdated = new VcsEvent();
-
-    /**
-     * @type {Set<import("@vcmap/core").FeatureStoreLayer>}
-     * @private
-     */
-    this._cachedFeatureStoreLayers = new Set();
-    this._activeMap = null;
-    this._layerCollection = null;
   }
 
   /**
    * The current Cesium.ClippingPlaneCollection. To update the collection, set this property to the new definition.
-   * @api
-   * @type {import("@vcmap/cesium").ClippingPlaneCollection|null}
    */
-  get clippingPlaneCollection() { return this._clippingPlaneCollection; }
+  get clippingPlaneCollection(): ClippingPlaneCollection | undefined {
+    return this._clippingPlaneCollection;
+  }
 
-  /**
-   * @param {import("@vcmap/cesium").ClippingPlaneCollection} clippingPlaneCollection
-   */
-  set clippingPlaneCollection(clippingPlaneCollection) {
+  set clippingPlaneCollection(
+    clippingPlaneCollection: ClippingPlaneCollection | undefined,
+  ) {
     this._clippingPlaneCollection = clippingPlaneCollection;
     this.clippingPlaneUpdated.raiseEvent();
   }
 
   /**
    * Flag to indicate whether the globe/terrain is part of the targets.
-   * @api
-   * @type {boolean}
    */
-  get terrain() { return this._terrain; }
+  get terrain(): boolean {
+    return this._terrain;
+  }
 
-  /**
-   * @param {boolean} terrain
-   */
-  set terrain(terrain) {
+  set terrain(terrain: boolean) {
     check(terrain, Boolean);
 
     if (this._terrain !== terrain) {
@@ -161,15 +131,12 @@ class ClippingObject {
    * Flag to indicate, whether this ClippingObject represents coordinates in a local frame. If false,
    * Plane coordiantes are assumed to be in ECEF or have an appropriate model matrix
    * applied to the Cesium.ClippingPlaneCollection.
-   * @api
-   * @type {boolean}
    */
-  get local() { return this._local; }
+  get local(): boolean {
+    return this._local;
+  }
 
-  /**
-   * @param {boolean} local
-   */
-  set local(local) {
+  set local(local: boolean) {
     check(local, Boolean);
 
     if (this._local !== local) {
@@ -178,10 +145,7 @@ class ClippingObject {
     }
   }
 
-  /**
-   * @param {import("@vcmap/core").LayerCollection} layerCollection
-   */
-  setLayerCollection(layerCollection) {
+  setLayerCollection(layerCollection: LayerCollection): void {
     check(layerCollection, LayerCollection);
 
     if (this._layerCollection && this._layerCollection !== layerCollection) {
@@ -193,65 +157,66 @@ class ClippingObject {
     });
   }
 
-  /**
-   * @param {import("@vcmap/core").Layer} layer
-   */
-  handleLayerChanged(layer) {
+  handleLayerChanged(layer: Layer): void {
     const map = this._activeMap;
     if (map instanceof CesiumMap) {
       if (this.layerNames.includes(layer.name)) {
         if (layer.active) {
           const visualisations = map.getVisualizationsForLayer(layer);
-          const tilesets = visualisations ?
-            [...visualisations]
-              .filter(v => v instanceof Cesium3DTileset) :
-            [];
+          const tilesets = visualisations
+            ? ([...visualisations].filter(
+                (v) => v instanceof Cesium3DTileset,
+              ) as Cesium3DTileset[])
+            : [];
 
           if (tilesets.length > 0) {
-            tilesets.forEach(/** @param {import("@vcmap/cesium").Cesium3DTileset} tileset */ (tileset) => {
-              tileset.readyPromise.then((cesium3DTileset) => {
-                if (this.layerNames.includes(layer.name) && layer.active) {
-                  this.targets.set(layer.name, cesium3DTileset);
-                  this.targetsUpdated.raiseEvent();
-                }
-              });
+            tilesets.forEach((tileset) => {
+              if (this.layerNames.includes(layer.name) && layer.active) {
+                this.targets.set(layer.name, tileset);
+                this.targetsUpdated.raiseEvent();
+              }
             });
           } else {
             const index = this.layerNames.indexOf(layer.name);
-            getLogger().warning(`layer ${layer.name} cannot have a ClippingObject applied`);
+            getLogger().warning(
+              `layer ${layer.name} cannot have a ClippingObject applied`,
+            );
             this.layerNames.splice(index, 1);
           }
         } else if (this.targets.has(layer.name)) {
           this.targets.delete(layer.name);
           this.targetsUpdated.raiseEvent();
         }
-      } else if (this.entities.find(eo => eo.layerName === layer.name)) {
+      } else if (this.entities.find((eo) => eo.layerName === layer.name)) {
         let raise = false;
         const visualisations = map.getVisualizationsForLayer(layer);
-        const dataSource = visualisations ?
-          [...visualisations][0] :
-          null;
+        const dataSource = visualisations ? [...visualisations][0] : null;
 
         if (!dataSource) {
           const index = this.layerNames.indexOf(layer.name);
-          getLogger().warning(`layer ${layer.name} cannot have a ClippingObject applied`);
+          getLogger().warning(
+            `layer ${layer.name} cannot have a ClippingObject applied`,
+          );
           this.layerNames.splice(index, 1);
           return;
         }
 
         this.entities
-          .filter(eo => eo.layerName === layer.name)
+          .filter((eo) => eo.layerName === layer.name)
           .forEach((eo) => {
             const key = `${eo.layerName}-${eo.entityId}`;
             if (layer.active) {
-              const entity = /** @type {import("@vcmap/cesium").CustomDataSource} */ (dataSource)
-                .entities.getById(eo.entityId);
+              const entity = (dataSource as CustomDataSource).entities.getById(
+                eo.entityId,
+              );
               if (entity) {
                 this.targets.set(key, entity);
                 raise = true;
               } else {
                 const index = this.entities.indexOf(eo);
-                getLogger().warning(`could not find entity with id ${eo.entityId} in layer ${eo.layerName}`);
+                getLogger().warning(
+                  `could not find entity with id ${eo.entityId} in layer ${eo.layerName}`,
+                );
                 this.entities.splice(index, 1);
               }
             } else if (this.targets.has(key)) {
@@ -264,21 +229,23 @@ class ClippingObject {
           this.targetsUpdated.raiseEvent();
         }
       }
-    } else if (this.layerNames.includes(layer.name) && layer.className === 'FeatureStoreLayer') {
+    } else if (
+      this.layerNames.includes(layer.name) &&
+      layer.className === 'FeatureStoreLayer'
+    ) {
       if (layer.active) {
-        this._cachedFeatureStoreLayers.add(/** @type {import("@vcmap/core").FeatureStoreLayer} */ (layer));
-      } else if (this._cachedFeatureStoreLayers.has(/** @type {import("@vcmap/core").FeatureStoreLayer} */ (layer))) {
-        this._cachedFeatureStoreLayers.delete(/** @type {import("@vcmap/core").FeatureStoreLayer} */ (layer));
+        this._cachedFeatureStoreLayers.add(layer as FeatureStoreLayer);
+      } else if (
+        this._cachedFeatureStoreLayers.has(layer as FeatureStoreLayer)
+      ) {
+        this._cachedFeatureStoreLayers.delete(layer as FeatureStoreLayer);
       }
     }
   }
 
-  /**
-   * @param {import("@vcmap/core").VcsMap|null} map
-   */
-  handleMapChanged(map) {
+  handleMapChanged(map: VcsMap | null): void {
     if (map instanceof CesiumMap) {
-      const { globe } = map.getScene();
+      const { globe } = map.getScene() as Scene;
       let raise = false;
       if (this._terrain && !this.targets.has(globeSymbol)) {
         this.targets.set(globeSymbol, globe);
@@ -293,7 +260,9 @@ class ClippingObject {
       }
 
       if (this._cachedFeatureStoreLayers.size > 0) {
-        this._cachedFeatureStoreLayers.forEach((layer) => { this.handleLayerChanged(layer); });
+        this._cachedFeatureStoreLayers.forEach((layer) => {
+          this.handleLayerChanged(layer);
+        });
         this._cachedFeatureStoreLayers.clear();
       }
     }
@@ -302,17 +271,16 @@ class ClippingObject {
 
   /**
    * add a layer name to the ClippingObject's layerNames array
-   * @api
-   * @param {string} layerName
+   * @param  layerName
    */
-  addLayer(layerName) {
+  addLayer(layerName: string): void {
     check(layerName, String);
 
     if (!this.layerNames.includes(layerName)) {
       this.layerNames.push(layerName);
-      const layer = this._layerCollection ?
-        this._layerCollection.getByKey(layerName) :
-        null;
+      const layer = this._layerCollection
+        ? this._layerCollection.getByKey(layerName)
+        : null;
       // XXX active state is not part of this yet
       if (layer && layer.active) {
         this.handleLayerChanged(layer);
@@ -322,10 +290,9 @@ class ClippingObject {
 
   /**
    * removes a layer from the ClippingObject's layerNames array
-   * @api
-   * @param {string} layerName
+   * @param  layerName
    */
-  removeLayer(layerName) {
+  removeLayer(layerName: string): void {
     check(layerName, String);
 
     const index = this.layerNames.indexOf(layerName);
@@ -341,19 +308,22 @@ class ClippingObject {
 
   /**
    * add an entity to the ClippingObject's entities array
-   * @api
-   * @param {string} layerName
-   * @param {string} entityId
+   * @param  layerName
+   * @param  entityId
    */
-  addEntity(layerName, entityId) {
+  addEntity(layerName: string, entityId: string): void {
     check(layerName, String);
     check(entityId, String);
 
-    if (!this.entities.find(eo => eo.layerName === layerName && eo.entityId === entityId)) {
+    if (
+      !this.entities.find(
+        (eo) => eo.layerName === layerName && eo.entityId === entityId,
+      )
+    ) {
       this.entities.push({ layerName, entityId });
-      const layer = this._layerCollection ?
-        this._layerCollection.getByKey(layerName) :
-        null;
+      const layer = this._layerCollection
+        ? this._layerCollection.getByKey(layerName)
+        : null;
       if (layer && layer.active) {
         this.handleLayerChanged(layer);
       }
@@ -362,15 +332,16 @@ class ClippingObject {
 
   /**
    * remove entity from the ClippingObject's entities array
-   * @api
-   * @param {string} layerName
-   * @param {string} entityId
+   * @param  layerName
+   * @param  entityId
    */
-  removeEntity(layerName, entityId) {
+  removeEntity(layerName: string, entityId: string): void {
     check(layerName, String);
     check(entityId, String);
 
-    const index = this.entities.findIndex(c => c.layerName === layerName && c.entityId === entityId);
+    const index = this.entities.findIndex(
+      (c) => c.layerName === layerName && c.entityId === entityId,
+    );
     if (index > -1) {
       this.entities.splice(index, 1);
     }