@vcmap/core 6.0.7 → 6.1.0-rc.2

package/dist/src/vectorCluster/vectorClusterSymbols.d.ts

@@ -0,0 +1 @@
+export declare const vectorClusterGroupName: unique symbol;

package/dist/src/vectorCluster/vectorClusterSymbols.js

@@ -0,0 +1,3 @@
+// eslint-disable-next-line import/prefer-default-export
+export const vectorClusterGroupName = Symbol('vectorClusterGroupName');
+//# sourceMappingURL=vectorClusterSymbols.js.map

package/dist/src/vectorCluster/vectorClusterSymbols.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"vectorClusterSymbols.js","sourceRoot":"","sources":["../../../src/vectorCluster/vectorClusterSymbols.ts"],"names":[],"mappings":"AAAA,wDAAwD;AACxD,MAAM,CAAC,MAAM,sBAAsB,GAAG,MAAM,CAAC,wBAAwB,CAAC,CAAC"}

package/index.ts

@@ -62,7 +62,6 @@ export {
   getExtentFromTileset,
   default as CesiumTilesetCesiumImpl,
 } from './src/layer/cesium/cesiumTilesetCesiumImpl.js';
-export { default as ClusterContext } from './src/layer/cesium/clusterContext.js';
 export { default as DataSourceCesiumImpl } from './src/layer/cesium/dataSourceCesiumImpl.js';
 export { default as OpenStreetMapCesiumImpl } from './src/layer/cesium/openStreetMapCesiumImpl.js';
 export { default as RasterLayerCesiumImpl } from './src/layer/cesium/rasterLayerCesiumImpl.js';
@@ -105,6 +104,10 @@ export {
   getTileHash,
   getTileWgs84Extent,
 } from './src/layer/cesium/vcsTile/vcsTileHelpers.js';
+export {
+  createSourceVectorContextSync,
+  SourceVectorContextSync,
+} from './src/layer/cesium/sourceVectorContextSync.js';
 export { default as CzmlLayer, CzmlOptions } from './src/layer/czmlLayer.js';
 export {
   default as DataSourceLayer,
@@ -183,6 +186,10 @@ export {
   setNewGeometry,
 } from './src/layer/oblique/obliqueHelpers.js';
 export { default as VectorObliqueImpl } from './src/layer/oblique/vectorObliqueImpl.js';
+export {
+  createSourceObliqueSync,
+  SourceObliqueSync,
+} from './src/layer/oblique/sourceObliqueSync.js';
 export {
   default as OpenStreetMapLayer,
   OpenStreetMapOptions,
@@ -257,6 +264,28 @@ export {
   default as URLTemplateTileProvider,
   URLTemplateTileProviderOptions,
 } from './src/layer/tileProvider/urlTemplateTileProvider.js';
+export {
+  default as ClusterContext,
+  default as VectorClusterCesiumContext,
+} from './src/vectorCluster/vectorClusterCesiumContext.js';
+export {
+  default as VectorClusterStyleItem,
+  VectorClusterStyleItemOptions,
+  VectorClusterTemplateFunction,
+  getDefaultClusterStyleItem,
+  getDefaultClusterHighlightStyleItem,
+} from './src/vectorCluster/vectorClusterStyleItem.js';
+export { default as VectorClusterGroupCesiumImpl } from './src/vectorCluster/vectorClusterGroupCesiumImpl.js';
+export { default as VectorClusterGroupOpenlayersImpl } from './src/vectorCluster/vectorClusterGroupOpenlayersImpl.js';
+export {
+  default as VectorClusterGroup,
+  VectorClusterGroupOptions,
+  VectorClusterGroupImplementationOptions,
+} from './src/vectorCluster/vectorClusterGroup.js';
+export { default as VectorClusterGroupImpl } from './src/vectorCluster/vectorClusterGroupImpl.js';
+export { default as VectorClusterGroupObliqueImpl } from './src/vectorCluster/vectorClusterGroupObliqueImpl.js';
+export { default as VectorClusterGroupCollection } from './src/vectorCluster/vectorClusterGroupCollection.js';
+export { vectorClusterGroupName } from './src/vectorCluster/vectorClusterSymbols.js';
 export {
   default as TMSLayer,
   TMSOptions,
@@ -496,6 +525,12 @@ export {
   getClippingOptions,
   ClippingPlaneCreationOptions,
 } from './src/util/clipping/clippingPlaneHelper.js';
+export {
+  default as ClippingPolygonObject,
+  ClippingPolygonObjectOptions,
+  ClippingPolygonObjectState,
+} from './src/util/clipping/clippingPolygonObject.js';
+export { default as ClippingPolygonObjectCollection } from './src/util/clipping/clippingPolygonObjectCollection.js';
 export {
   default as DisplayQuality,
   DisplayQualityLevel,
@@ -833,3 +868,9 @@ export {
 } from './src/util/flight/flightVisualizer.js';
 export { getTileLoadFunction } from './src/layer/openlayers/loadFunctionHelpers.js';
 export { default as ModelFill } from './src/style/modelFill.js';
+export { renderTemplate } from './src/util/vcsTemplate.js';
+export {
+  startRotation,
+  rotationMapControlSymbol,
+} from './src/util/rotation.js';
+export { default as renderScreenshot } from './src/util/renderScreenshot.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vcmap/core",
-  "version": "6.0.7",
+  "version": "6.1.0-rc.2",
   "description": "",
   "main": "dist/index.js",
   "type": "module",
@@ -39,6 +39,7 @@
   "license": "MIT",
   "devDependencies": {
     "@types/chai": "^4.3.16",
+    "@types/chai-as-promised": "^8.0.1",
     "@types/geojson": "^7946.0.10",
     "@types/mocha": "^10.0.7",
     "@types/node": "^20.16.5",
@@ -50,6 +51,7 @@
     "c8": "^10.1.2",
     "canvas": "^2.11.2",
     "chai": "^4.4.1",
+    "chai-as-promised": "^8.0.1",
     "eslint": "^8.38.0",
     "jsdom": "^24.1.0",
     "jsdom-global": "^3.0.2",

package/src/cesium/cesium.d.ts

@@ -27,6 +27,7 @@ import {
   updateFeatureOverride,
 } from '../layer/cesium/cesiumTilesetCesiumImpl.js';
 import { isTiledFeature } from '../layer/featureStoreLayer.js';
+import { vectorClusterGroupName } from '../vectorCluster/vectorClusterSymbols.js';
 
 declare module '@vcmap-cesium/engine' {
   interface Scene {
@@ -61,6 +62,7 @@ declare module '@vcmap-cesium/engine' {
     getPropertyInherited(key: string): any;
     getAttributes(): Record<string, unknown>;
     [vcsLayerName]?: string;
+    [vectorClusterGroupName]?: string;
     [globalHidden]?: boolean;
     [hidden]?: boolean;
     [highlighted]?: VectorStyleItem;
@@ -112,6 +114,7 @@ declare module '@vcmap-cesium/engine' {
 
   interface CustomDataSource {
     [vcsLayerName]?: string;
+    [vectorClusterGroupName]?: string;
   }
 
   interface CzmlDataSource {

package/src/featureProvider/featureProviderSymbols.ts

@@ -1,5 +1,10 @@
 /**
  * Added to ol.Feature, if they are not part of a layer, but provided by an {@link AbstractFeatureProvider}.
  */
-// eslint-disable-next-line import/prefer-default-export
 export const isProvidedFeature: unique symbol = Symbol('isProvidedFeature');
+
+/**
+ * Added to ol.Feature, if a {@link AbstractFeatureProvider} provides more than one feature for one location.
+ * The provided feature is a cluster feature. The single features can be accessed by `feature.get('features')`.
+ */
+export const isProvidedClusterFeature = Symbol('isProvidedClusterFeature');

package/src/interaction/featureAtPixelInteraction.ts

@@ -5,10 +5,11 @@ import {
   Cesium3DTileFeature,
   Cesium3DTilePointFeature,
   Entity,
+  Scene,
+  Cartesian2,
 } from '@vcmap-cesium/engine';
+import OLMap from 'ol/Map.js';
 import type { Feature } from 'ol/index.js';
-import type { Layer as OLLayer } from 'ol/layer.js';
-
 import AbstractInteraction, {
   type EventFeature,
   type InteractionEvent,
@@ -25,6 +26,96 @@ import type OpenlayersMap from '../map/openlayersMap.js';
 import type ObliqueMap from '../map/obliqueMap.js';
 import type CesiumMap from '../map/cesiumMap.js';
 
+/**
+ * This is the return from cesium scene.pick and scene.drillPick, which returns "any". We cast to this type.
+ */
+type CesiumPickObject = {
+  primitive?: {
+    olFeature?: Feature;
+    pointCloudShading?: { attenuation: unknown };
+    [vcsLayerName]?: string;
+  };
+  id?: {
+    olFeature?: Feature;
+    [vcsLayerName]?: string;
+  };
+};
+
+function getFeatureFromOlMap(
+  map: OLMap,
+  pixel: [number, number],
+  hitTolerance: number,
+): Feature | undefined {
+  let feature: Feature | undefined;
+  map.forEachFeatureAtPixel(
+    pixel,
+    (feat) => {
+      if (
+        feat &&
+        (feat.get('olcs_allowPicking') == null ||
+          feat.get('olcs_allowPicking') === true)
+      ) {
+        feature = (feat as Feature)[originalFeatureSymbol] || (feat as Feature);
+      }
+      return true;
+    },
+    { hitTolerance },
+  );
+
+  return feature;
+}
+
+function getFeatureFromPickObject(
+  object: CesiumPickObject,
+): EventFeature | undefined {
+  let feature: EventFeature | undefined;
+  if (object.primitive && object.primitive.olFeature) {
+    feature = object.primitive.olFeature;
+  } else if (
+    object.primitive &&
+    object.primitive[vcsLayerName] &&
+    (object instanceof Cesium3DTileFeature ||
+      object instanceof Cesium3DTilePointFeature)
+  ) {
+    // cesium 3d tileset
+    feature = object;
+    const symbols = Object.getOwnPropertySymbols(object.primitive);
+    const symbolLength = symbols.length;
+    for (let i = 0; i < symbolLength; i++) {
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-ignore
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+      feature[symbols[i]] = object.primitive[symbols[i]];
+    }
+  } else if (object.id && object.id.olFeature) {
+    // cluster size === 1
+    feature = object.id.olFeature;
+  } else if (
+    object.id &&
+    object.id[vcsLayerName] &&
+    object.id instanceof Entity
+  ) {
+    // entity
+    feature = object.id;
+  }
+
+  return feature;
+}
+
+function getFeatureFromScene(
+  scene: Scene,
+  windowPosition: Cartesian2,
+  hitTolerance: number,
+): EventFeature | undefined {
+  const pickObject = scene.pick(
+    windowPosition,
+    hitTolerance,
+    hitTolerance,
+  ) as CesiumPickObject;
+
+  return getFeatureFromPickObject(pickObject);
+}
+
 /**
  * @group Interaction
  */
@@ -100,54 +191,28 @@ class FeatureAtPixelInteraction extends AbstractInteraction {
   private _openlayersHandler(
     event: InteractionEvent,
   ): Promise<InteractionEvent> {
-    let found: Feature | null = null;
-    let foundLayer: OLLayer | null = null;
-    (event.map as OpenlayersMap).olMap!.forEachFeatureAtPixel(
+    const feature = getFeatureFromOlMap(
+      (event.map as OpenlayersMap).olMap!,
       [event.windowPosition.x, event.windowPosition.y],
-      (feat, layer) => {
-        if (
-          feat &&
-          (feat.get('olcs_allowPicking') == null ||
-            feat.get('olcs_allowPicking') === true)
-        ) {
-          found = feat as Feature;
-          foundLayer = layer;
-        }
-        return true;
-      },
-      { hitTolerance: this.hitTolerance },
+      this.hitTolerance,
     );
 
-    if (found && foundLayer) {
-      event.feature = found as Feature;
-      if (event.feature.get('features') as Feature[] | undefined) {
-        event.feature[vcsLayerName] = foundLayer[vcsLayerName];
-      }
+    if (feature) {
+      event.feature = feature;
       event.exactPosition = true;
     }
     return Promise.resolve(event);
   }
 
   private _obliqueHandler(event: InteractionEvent): Promise<InteractionEvent> {
-    let found: Feature | null = null;
-    let foundLayer: OLLayer | null = null;
-    (event.map as ObliqueMap).olMap!.forEachFeatureAtPixel(
+    const feature = getFeatureFromOlMap(
+      (event.map as ObliqueMap).olMap!,
       [event.windowPosition.x, event.windowPosition.y],
-      (feat, layer) => {
-        if (feat) {
-          found = (feat as Feature)[originalFeatureSymbol] || (feat as Feature);
-        }
-        foundLayer = layer;
-        return true;
-      },
-      { hitTolerance: this.hitTolerance },
+      this.hitTolerance,
     );
 
-    if (found && foundLayer) {
-      event.feature = found as Feature;
-      if (event.feature.get('features') as Feature[] | undefined) {
-        event.feature[vcsLayerName] = foundLayer[vcsLayerName];
-      }
+    if (feature) {
+      event.feature = feature;
       event.exactPosition = true;
     }
     return Promise.resolve(event);
@@ -161,21 +226,11 @@ class FeatureAtPixelInteraction extends AbstractInteraction {
       return Promise.resolve(event);
     }
 
-    const object = scene.pick(
+    const feature = getFeatureFromScene(
+      scene,
       event.windowPosition,
       this.hitTolerance,
-      this.hitTolerance,
-    ) as {
-      primitive?: {
-        olFeature?: Feature;
-        pointCloudShading?: { attenuation: unknown };
-        [vcsLayerName]?: string;
-      };
-      id?: {
-        olFeature?: Feature;
-        [vcsLayerName]?: string;
-      };
-    };
+    );
 
     let scratchCartographic = new Cartographic();
     let scratchCartesian = new Cartesian3();
@@ -220,44 +275,14 @@ class FeatureAtPixelInteraction extends AbstractInteraction {
       return Promise.resolve(event);
     };
 
-    if (object) {
-      if (object.primitive && object.primitive.olFeature) {
-        // vector & vectorCluster
-        event.feature = object.primitive.olFeature;
-      } else if (
-        object.primitive &&
-        object.primitive[vcsLayerName] &&
-        (object instanceof Cesium3DTileFeature ||
-          object instanceof Cesium3DTilePointFeature)
-      ) {
-        // building
-        event.feature = object;
-        const symbols = Object.getOwnPropertySymbols(object.primitive);
-        const symbolLength = symbols.length;
-        for (let i = 0; i < symbolLength; i++) {
-          // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-          // @ts-ignore
-          // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-          event.feature[symbols[i]] = object.primitive[symbols[i]];
-        }
-      } else if (object.id && object.id.olFeature) {
-        // cluster size === 1
-        event.feature = object.id.olFeature;
-      } else if (
-        object.id &&
-        object.id[vcsLayerName] &&
-        object.id instanceof Entity
-      ) {
-        // entity
-        event.feature = object.id;
-      }
-
+    if (feature) {
+      event.feature = feature;
       if (!(event.type & this.pickPosition)) {
         return Promise.resolve(event);
       }
 
       if (scene.pickPositionSupported) {
-        if (object.primitive && this.pickTranslucent) {
+        if (this.pickTranslucent) {
           scene.pickTranslucentDepth = true;
           event.exactPosition = true;
         }

package/src/interaction/featureProviderInteraction.ts

@@ -1,5 +1,7 @@
 import type { Coordinate } from 'ol/coordinate.js';
 
+import Point from 'ol/geom/Point.js';
+import Feature from 'ol/Feature.js';
 import AbstractInteraction, {
   type InteractionEvent,
 } from './abstractInteraction.js';
@@ -8,6 +10,10 @@ import {
   ModificationKeyType,
   PointerKeyType,
 } from './interactionType.js';
+import {
+  isProvidedClusterFeature,
+  isProvidedFeature,
+} from '../featureProvider/featureProviderSymbols.js';
 
 /**
  * @group Interaction
@@ -21,36 +27,44 @@ class FeatureProviderInteraction extends AbstractInteraction {
 
   // eslint-disable-next-line class-methods-use-this
   async pipe(event: InteractionEvent): Promise<InteractionEvent> {
-    if (!event.feature) {
-      const layersWithProvider = [...event.map.layerCollection]
-        .filter((l) => {
-          return (
-            l.featureProvider &&
-            l.active &&
-            l.isSupported(event.map) &&
-            l.featureProvider.isSupported(event.map)
-          );
-        })
-        .reverse();
-
-      if (layersWithProvider.length > 0) {
-        const resolution = event.map.getCurrentResolution(
-          event.position as Coordinate,
+    const layersWithProvider = [...event.map.layerCollection]
+      .filter((l) => {
+        return (
+          l.featureProvider &&
+          l.active &&
+          l.isSupported(event.map) &&
+          l.featureProvider.isSupported(event.map)
         );
-        const features = (
-          await Promise.all(
-            layersWithProvider.map(
-              (l) =>
-                l.featureProvider?.getFeaturesByCoordinate?.(
-                  event.position as Coordinate,
-                  resolution,
-                  l.headers,
-                ),
-            ),
-          )
-        ).flat();
+      })
+      .reverse();
+
+    if (layersWithProvider.length > 0) {
+      const resolution = event.map.getCurrentResolution(
+        event.position as Coordinate,
+      );
+      const features = (
+        await Promise.all(
+          layersWithProvider.map(
+            (l) =>
+              l.featureProvider?.getFeaturesByCoordinate?.(
+                event.position as Coordinate,
+                resolution,
+                l.headers,
+              ),
+          ),
+        )
+      )
+        .filter((f) => !!f)
+        .flat();
 
-        if (features.length > 0) {
+      if (features.length > 0) {
+        if (features.length > 1) {
+          const feature = new Feature({ features });
+          feature[isProvidedFeature] = true; // backward compatibility, may remove in future
+          feature[isProvidedClusterFeature] = true;
+          feature.setGeometry(new Point(event.position as Coordinate));
+          event.feature = feature;
+        } else if (!event.feature) {
           event.feature = features[0];
         }
       }

package/src/layer/cesium/sourceVectorContextSync.ts

@@ -0,0 +1,134 @@
+import { getLogger } from '@vcsuite/logger';
+import { unByKey } from 'ol/Observable.js';
+import type VectorSource from 'ol/source/Vector.js';
+import type { Feature } from 'ol';
+import { StyleLike } from 'ol/style/Style.js';
+import type { Scene } from '@vcmap-cesium/engine';
+import type VectorContext from './vectorContext.js';
+import type VectorClusterCesiumContext from '../../vectorCluster/vectorClusterCesiumContext.js';
+import VectorProperties from '../vectorProperties.js';
+
+export type SourceVectorContextSync = {
+  readonly active: boolean;
+  activate(): void;
+  deactivate(): void;
+  /**
+   * Clears the context and adds all features from the source.
+   */
+  refresh(): void;
+  destroy(): void;
+};
+
+/**
+ * Creates a SourceVectorContextSync. This ensures that the features in the source are synced to the context.
+ * Adding, removing and changing features in the source will be reflected in the context.
+ * @param source
+ * @param context
+ * @param scene
+ * @param style
+ * @param vectorProperties - the vector properties or a function returning vector properties for a feature
+ */
+export function createSourceVectorContextSync(
+  source: VectorSource,
+  context: VectorContext | VectorClusterCesiumContext,
+  scene: Scene,
+  style: StyleLike,
+  vectorProperties: VectorProperties | ((f: Feature) => VectorProperties),
+): SourceVectorContextSync {
+  const featureToAdd = new Set<Feature>();
+  let active = false;
+  const vectorPropertiesChanged = new Map<VectorProperties, () => void>();
+  const getVectorProperties =
+    typeof vectorProperties === 'function'
+      ? vectorProperties
+      : (): VectorProperties => vectorProperties;
+
+  let refresh: () => void;
+  const addFeature = async (feature: Feature): Promise<void> => {
+    const featureVectorProperties = getVectorProperties(feature);
+    if (!vectorPropertiesChanged.has(featureVectorProperties)) {
+      vectorPropertiesChanged.set(
+        featureVectorProperties,
+        featureVectorProperties.propertyChanged.addEventListener(refresh),
+      );
+    }
+    if (active) {
+      // XXX cluster check here? or on init?
+      await context.addFeature(feature, style, featureVectorProperties, scene);
+    } else {
+      featureToAdd.add(feature);
+    }
+  };
+
+  const removeFeature = (feature: Feature): void => {
+    context.removeFeature(feature);
+    featureToAdd.delete(feature);
+  };
+
+  const featureChanged = async (feature: Feature): Promise<void> => {
+    featureToAdd.delete(feature);
+    await addFeature(feature);
+  };
+
+  const addFeatures = (features: Feature[]): void => {
+    // TODO we should make this non-blocking to better handle larger data sets check in RIWA Impl
+    features.forEach((f) => {
+      addFeature(f).catch((err) => {
+        getLogger('SourceVectorContextSync').error(
+          'failed to convert feature',
+          f,
+          err,
+        );
+      });
+    });
+  };
+
+  const addCachedFeatures = (): void => {
+    addFeatures([...featureToAdd]);
+    featureToAdd.clear();
+  };
+
+  refresh = (): void => {
+    context.clear();
+    addFeatures(source.getFeatures());
+  };
+
+  const olListeners = [
+    source.on('addfeature', (event) => {
+      addFeature(event.feature as Feature).catch(() => {
+        getLogger().error('failed to convert feature');
+      });
+    }),
+    source.on('removefeature', (event) => {
+      removeFeature(event.feature as Feature);
+    }),
+    source.on('changefeature', (event) => {
+      featureChanged(event.feature as Feature).catch((_e) => {
+        getLogger().error('failed to convert feature');
+      });
+    }),
+  ];
+
+  addFeatures(source.getFeatures());
+
+  return {
+    get active(): boolean {
+      return active;
+    },
+    activate(): void {
+      active = true;
+      addCachedFeatures();
+    },
+    deactivate(): void {
+      active = false;
+    },
+    refresh,
+    destroy(): void {
+      unByKey(olListeners);
+      vectorPropertiesChanged.forEach((removeListener) => {
+        removeListener();
+      });
+      vectorPropertiesChanged.clear();
+    },
+  };
+}

package/src/layer/cesium/vcsTile/vcsDebugTile.ts

@@ -29,7 +29,7 @@ import Projection, {
 import { createSync } from '../../vectorSymbols.js';
 import VectorProperties from '../../vectorProperties.js';
 import CesiumMap from '../../../map/cesiumMap.js';
-import { TileProvider } from '../../../../index.js';
+import type TileProvider from '../../tileProvider/tileProvider.js';
 
 let vectorProperties: VectorProperties | undefined;
 function getDebugVectorProperties(): VectorProperties {

package/src/layer/cesium/vcsTile/vcsVectorTile.ts

@@ -19,8 +19,8 @@ import {
   VcsTileType,
 } from './vcsTileHelpers.js';
 import CesiumMap from '../../../map/cesiumMap.js';
-import { TileProvider } from '../../../../index.js';
 import VectorProperties from '../../vectorProperties.js';
+import type TileProvider from '../../tileProvider/tileProvider.js';
 
 export default class VcsVectorTile implements VcsTile {
   state = VcsTileState.LOADING;