@vcmap/core 6.3.0-rc.1 → 6.3.0-rc.2

package/src/featureProvider/tileProviderFeatureProvider.ts

@@ -3,8 +3,8 @@ import type { Feature } from 'ol/index.js';
 import AbstractFeatureProvider, {
   type AbstractFeatureProviderOptions,
 } from './abstractFeatureProvider.js';
-import { featureProviderClassRegistry } from '../classRegistry.js';
 import type TileProvider from '../layer/tileProvider/tileProvider.js';
+import type Layer from '../layer/layer.js';
 
 export type TileProviderFeatureProviderOptions =
   AbstractFeatureProviderOptions & {
@@ -18,26 +18,21 @@ class TileProviderFeatureProvider extends AbstractFeatureProvider {
 
   tileProvider: TileProvider;
 
-  /**
-   * @param  layerName
-   * @param  options
-   */
-  constructor(layerName: string, options: TileProviderFeatureProviderOptions) {
-    super(layerName, options);
+  constructor(options: TileProviderFeatureProviderOptions) {
+    super({ ...options, mapTypes: ['CesiumMap'] });
 
-    this.mapTypes = ['CesiumMap'];
     this.tileProvider = options.tileProvider;
   }
 
   async getFeaturesByCoordinate(
     coordinate: Coordinate,
     resolution: number,
-    headers?: Record<string, string>,
+    layer: Layer,
   ): Promise<Feature[]> {
     const features = await this.tileProvider.getFeaturesByCoordinate(
       coordinate,
       resolution,
-      headers,
+      layer.headers,
     );
     const checkShow = (feature: Feature): boolean =>
       this.style ? !!this.style.cesiumStyle.show.evaluate(feature) : true;
@@ -48,6 +43,14 @@ class TileProviderFeatureProvider extends AbstractFeatureProvider {
     });
   }
 
+  toJSON(
+    defaultOptions: AbstractFeatureProviderOptions = AbstractFeatureProvider.getDefaultOptions(),
+  ): AbstractFeatureProviderOptions {
+    const options = super.toJSON(defaultOptions);
+    delete options.mapTypes;
+    return options;
+  }
+
   destroy(): void {
     this.tileProvider.destroy();
     super.destroy();
@@ -55,7 +58,3 @@ class TileProviderFeatureProvider extends AbstractFeatureProvider {
 }
 
 export default TileProviderFeatureProvider;
-featureProviderClassRegistry.registerClass(
-  TileProviderFeatureProvider.className,
-  TileProviderFeatureProvider,
-);

package/src/featureProvider/urlIdAttributeProvider.ts

@@ -0,0 +1,82 @@
+import AbstractAttributeProvider from './abstractAttributeProvider.js';
+import type { VcsObjectOptions } from '../vcsObject.js';
+import { getInitForUrl, requestJson } from '../util/fetch.js';
+import { featureProviderClassRegistry } from '../classRegistry.js';
+
+export type UrlIdAttributeProviderOptions = VcsObjectOptions & {
+  urlTemplate: string;
+  headers?: Record<string, string>;
+};
+
+/**
+ * Provides attributes for features by fetching data from a URL based on feature IDs.
+ * The URL template should contain a {id} placeholder that will be replaced with the encoded feature ID.
+ * urlTemplate: 'https://api.example.com/features/{id}'
+ * For a feature with ID "123", this would request: https://api.example.com/features/123
+ *
+ * The backend should return a JSON object with attribute key-value pairs.
+ * {
+ * "name": "Feature Name",
+ * "description": "Feature description",
+ * "value": 42
+ * }
+ * If the request fails or returns invalid data, the provider returns undefined.
+ */
+export default class UrlIdAttributeProvider extends AbstractAttributeProvider {
+  static get className(): string {
+    return 'UrlIdAttributeProvider';
+  }
+
+  private _urlTemplate: string;
+
+  private _headers?: Record<string, string> | undefined;
+
+  constructor(options: UrlIdAttributeProviderOptions) {
+    super(options);
+
+    this._urlTemplate = options.urlTemplate;
+
+    this._headers = options.headers
+      ? structuredClone(options.headers)
+      : undefined;
+  }
+
+  protected async _getAttributes(
+    id: string,
+  ): Promise<Record<string, unknown> | undefined> {
+    const url = this._urlTemplate.replace(
+      '{id}',
+      encodeURIComponent(String(id)),
+    );
+
+    try {
+      return await requestJson<Record<string, unknown>>(
+        url,
+        getInitForUrl(url, this._headers),
+      );
+    } catch {
+      return undefined;
+    }
+  }
+
+  override toJSON(
+    _defaultOptions?: UrlIdAttributeProviderOptions,
+  ): UrlIdAttributeProviderOptions {
+    const config: Partial<UrlIdAttributeProviderOptions> = super.toJSON(
+      _defaultOptions,
+    );
+
+    config.urlTemplate = this._urlTemplate;
+
+    if (this._headers) {
+      config.headers = structuredClone(this._headers);
+    }
+
+    return config as UrlIdAttributeProviderOptions;
+  }
+}
+
+featureProviderClassRegistry.registerClass(
+  UrlIdAttributeProvider.className,
+  UrlIdAttributeProvider,
+);

package/src/featureProvider/wmsFeatureProvider.ts

@@ -16,7 +16,7 @@ import type { Options as WMSGetFeatureInfoOptions } from 'ol/format/WMSGetFeatur
 import { containsCoordinate } from 'ol/extent.js';
 import { parseInteger } from '@vcsuite/parsers';
 import { getLogger } from '@vcsuite/logger';
-import type { AbstractFeatureProviderOptions } from './abstractFeatureProvider.js';
+import { type AbstractFeatureProviderOptions } from './abstractFeatureProvider.js';
 import AbstractFeatureProvider from './abstractFeatureProvider.js';
 import type { ProjectionOptions } from '../util/projection.js';
 import Projection, { mercatorProjection } from '../util/projection.js';
@@ -27,6 +27,7 @@ import Extent from '../util/extent.js';
 import { getInitForUrl, requestUrl } from '../util/fetch.js';
 import { featureProviderClassRegistry } from '../classRegistry.js';
 import { TilingScheme } from '../layer/rasterLayer.js';
+import type Layer from '../layer/layer.js';
 
 export type FormatOptions = GeoJSONOptions &
   GMLOptions &
@@ -78,6 +79,10 @@ export type WMSFeatureProviderOptions = AbstractFeatureProviderOptions & {
    */
   version?: string;
   htmlPositionFeatureTitle?: string;
+  /**
+   * Optional headers to include in GetFeatureInfo requests. Overrides layer headers.
+   */
+  headers?: Record<string, string>;
 };
 
 const gmlFormats = { GML: GML3, GML2, GML3, GML32 };
@@ -191,6 +196,7 @@ class WMSFeatureProvider extends AbstractFeatureProvider {
       tileSize: [256, 256],
       parameters: {},
       extent: undefined,
+      headers: undefined,
     };
   }
 
@@ -233,9 +239,14 @@ class WMSFeatureProvider extends AbstractFeatureProvider {
 
   htmlPositionFeatureTitle?: string;
 
-  constructor(layerName: string, options: WMSFeatureProviderOptions) {
+  /**
+   * Optional headers to include in GetFeatureInfo requests.
+   */
+  headers?: Record<string, string>;
+
+  constructor(options: WMSFeatureProviderOptions) {
     const defaultOptions = WMSFeatureProvider.getDefaultOptions();
-    super(layerName, { ...defaultOptions, ...options });
+    super({ ...defaultOptions, ...options });
 
     if (options.extent) {
       if (options.extent instanceof Extent) {
@@ -271,6 +282,9 @@ class WMSFeatureProvider extends AbstractFeatureProvider {
       ? new Projection(options.projection)
       : undefined;
     this.htmlPositionFeatureTitle = options.htmlPositionFeatureTitle;
+    this.headers = options.headers
+      ? structuredClone(options.headers)
+      : undefined;
   }
 
   get wmsSource(): TileWMS {
@@ -324,7 +338,7 @@ class WMSFeatureProvider extends AbstractFeatureProvider {
   async getFeaturesByCoordinate(
     coordinate: Coordinate,
     resolution: number,
-    headers?: Record<string, string>,
+    layer: Layer,
   ): Promise<Feature[]> {
     if (
       this.extent?.isValid() &&
@@ -354,10 +368,10 @@ class WMSFeatureProvider extends AbstractFeatureProvider {
 
     if (this.featureInfoResponseType === 'text/html') {
       return this.featureResponseCallback(null, coordinate).map((f) =>
-        this.getProviderFeature(f),
+        this.getProviderFeature(f, layer),
       );
     } else if (url) {
-      const init = getInitForUrl(url, headers);
+      const init = getInitForUrl(url, this.headers ?? layer.headers);
       let data: string;
       try {
         const response = await requestUrl(url, init);
@@ -367,7 +381,7 @@ class WMSFeatureProvider extends AbstractFeatureProvider {
         return [];
       }
       return this.featureResponseCallback(data, coordinate).map((f) =>
-        this.getProviderFeature(f),
+        this.getProviderFeature(f, layer),
       );
     }
     return [];
@@ -427,6 +441,9 @@ class WMSFeatureProvider extends AbstractFeatureProvider {
     if (this.htmlPositionFeatureTitle) {
       config.htmlPositionFeatureTitle = this.htmlPositionFeatureTitle;
     }
+    if (this.headers) {
+      config.headers = structuredClone(this.headers);
+    }
 
     return config as WMSFeatureProviderOptions;
   }

package/src/global.d.ts

@@ -12,6 +12,8 @@ declare global {
       createModuleFromConfig: (config: VcsModuleConfig) => VcsModule;
       getFirstApp: () => VcsApp | undefined;
       workerBase?: string;
+      scriptNonce?: string;
+      styleNonce?: string;
     };
     opera?: string;
   }

package/src/interaction/featureAtPixelInteraction.ts

@@ -4,6 +4,8 @@ import type {
   Ray,
   Billboard,
   Label,
+  I3SNode,
+  I3SDataProvider,
 } from '@vcmap-cesium/engine';
 import {
   Cartesian3,
@@ -12,7 +14,9 @@ import {
   Entity,
 } from '@vcmap-cesium/engine';
 import type OLMap from 'ol/Map.js';
-import type { Feature } from 'ol/index.js';
+import Feature from 'ol/Feature.js';
+import { Point } from 'ol/geom.js';
+import { v4 as uuid } from 'uuid';
 import AbstractInteraction, {
   type EventFeature,
   type InteractionEvent,
@@ -22,7 +26,7 @@ import {
   ModificationKeyType,
   PointerKeyType,
 } from './interactionType.js';
-import { allowPicking, vcsLayerName } from '../layer/layerSymbols.js';
+import { allowPicking, i3sData, vcsLayerName } from '../layer/layerSymbols.js';
 import { originalFeatureSymbol, primitives } from '../layer/vectorSymbols.js';
 import type OpenlayersMap from '../map/openlayersMap.js';
 import type ObliqueMap from '../map/obliqueMap.js';
@@ -31,6 +35,7 @@ import { cartesian3DDistance, cartesianToMercator } from '../util/math.js';
 import type { PrimitiveType } from '../util/featureconverter/convert.js';
 import type BaseCesiumMap from '../map/baseCesiumMap.js';
 import type PanoramaMap from '../map/panoramaMap.js';
+import { isProvidedFeature } from '../featureProvider/featureProviderSymbols.js';
 
 /**
  * This is the return from cesium scene.pick and scene.drillPick, which returns "any". We cast to this type.
@@ -45,6 +50,11 @@ type CesiumPickObject = {
     olFeature?: Feature;
     [vcsLayerName]?: string;
   };
+  content?: {
+    tile?: {
+      i3sNode: I3SNode;
+    };
+  };
 };
 
 function getFeatureFromOlMap(
@@ -81,6 +91,12 @@ function getFeatureFromOlMap(
   return feature;
 }
 
+export function isI3SFeature(f: EventFeature): f is Feature & {
+  [i3sData]: { i3sNode: I3SNode; cartesianPosition?: Cartesian3 };
+} {
+  return !!(f != null && (f as Feature)[i3sData]);
+}
+
 export function getFeatureFromPickObject(
   object: CesiumPickObject,
 ): EventFeature | undefined {
@@ -114,8 +130,24 @@ export function getFeatureFromPickObject(
   ) {
     // entity
     feature = object.id;
+  } else if (object.content?.tile?.i3sNode) {
+    // i3s feature
+    const dataProvider =
+      // @ts-expect-error eslint-disable-next-line no-underscore-dangle, @typescript-eslint/ban-ts-comment
+      // eslint-disable-next-line no-underscore-dangle
+      object.content.tile.i3sNode._dataProvider as I3SDataProvider;
+    const layername = dataProvider[vcsLayerName];
+    if (object instanceof Cesium3DTileFeature) {
+      feature = object;
+      feature[vcsLayerName] = layername;
+    } else if (dataProvider[allowPicking] !== false) {
+      feature = new Feature({});
+      feature.setId(uuid());
+      feature[vcsLayerName] = layername;
+      feature[i3sData] = { i3sNode: object.content.tile.i3sNode };
+      feature[isProvidedFeature] = true;
+    }
   }
-
   return feature;
 }
 
@@ -350,6 +382,15 @@ class FeatureAtPixelInteraction extends AbstractInteraction {
         if (event.map.className === 'CesiumMap') {
           event.position = cartesianToMercator(cartesianPosition);
           event.positionOrPixel = event.position.slice();
+          if (
+            feature instanceof Feature &&
+            feature[isProvidedFeature] &&
+            isI3SFeature(feature)
+          ) {
+            feature.setGeometry(new Point(event.position));
+            feature.set('olcs_altitudeMode', 'absolute');
+            feature[i3sData].cartesianPosition = cartesianPosition;
+          }
         } else {
           const currentImage = (event.map as PanoramaMap).currentPanoramaImage;
           if (currentImage) {
@@ -363,6 +404,15 @@ class FeatureAtPixelInteraction extends AbstractInteraction {
             if (currentDistance == null || newDistance < currentDistance) {
               event.position = newPosition;
               event.positionOrPixel = event.position.slice();
+              if (
+                feature instanceof Feature &&
+                feature[isProvidedFeature] &&
+                isI3SFeature(feature)
+              ) {
+                feature.setGeometry(new Point(event.position));
+                feature.set('olcs_altitudeMode', 'absolute');
+                feature[i3sData].cartesianPosition = cartesianPosition;
+              }
             }
           }
         }

package/src/interaction/featureProviderInteraction.ts

@@ -1,8 +1,8 @@
 import type { Coordinate } from 'ol/coordinate.js';
-
 import Point from 'ol/geom/Point.js';
 import Feature from 'ol/Feature.js';
 import AbstractInteraction, {
+  type EventFeature,
   type InteractionEvent,
 } from './abstractInteraction.js';
 import {
@@ -14,6 +14,10 @@ import {
   isProvidedClusterFeature,
   isProvidedFeature,
 } from '../featureProvider/featureProviderSymbols.js';
+import AbstractFeatureProvider from '../featureProvider/abstractFeatureProvider.js';
+import { vcsLayerName } from '../layer/layerSymbols.js';
+import CompositeFeatureProvider from '../featureProvider/compositeFeatureProvider.js';
+import AbstractAttributeProvider from '../featureProvider/abstractAttributeProvider.js';
 
 /**
  * @group Interaction
@@ -27,50 +31,67 @@ class FeatureProviderInteraction extends AbstractInteraction {
 
   // eslint-disable-next-line class-methods-use-this
   async pipe(event: InteractionEvent): Promise<InteractionEvent> {
-    if (event.feature) {
-      return event;
-    }
+    if (!event.feature) {
+      const layersWithProvider = [...event.map.layerCollection]
+        .filter((l) => {
+          return (
+            l.featureProvider instanceof AbstractFeatureProvider &&
+            l.active &&
+            l.isSupported(event.map) &&
+            l.featureProvider.isSupported(event.map)
+          );
+        })
+        .reverse();
 
-    const layersWithProvider = [...event.map.layerCollection]
-      .filter((l) => {
-        return (
-          l.featureProvider &&
-          l.active &&
-          l.isSupported(event.map) &&
-          l.featureProvider.isSupported(event.map)
+      if (layersWithProvider.length > 0) {
+        const resolution = event.map.getCurrentResolution(
+          event.position as Coordinate,
         );
-      })
-      .reverse();
-
-    if (layersWithProvider.length > 0) {
-      const resolution = event.map.getCurrentResolution(
-        event.position as Coordinate,
-      );
-      // TODO make sure the layers are rendered, check min/max RenderingResolution
-      const features = (
-        await Promise.all(
-          layersWithProvider.map((l) =>
-            l.featureProvider?.getFeaturesByCoordinate?.(
-              event.position as Coordinate,
-              resolution,
-              l.headers,
+        // TODO make sure the layers are rendered, check min/max RenderingResolution
+        const features = (
+          await Promise.all(
+            layersWithProvider.map((l) =>
+              (
+                l.featureProvider as AbstractFeatureProvider
+              ).getFeaturesByCoordinate?.(
+                event.position as Coordinate,
+                resolution,
+                l,
+              ),
             ),
-          ),
+          )
         )
-      )
-        .filter((f) => !!f)
-        .flat();
-      if (features.length === 1) {
-        event.feature = features[0];
-      } else 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;
+          .filter((f) => !!f)
+          .flat();
+        if (features.length === 1) {
+          event.feature = features[0];
+        } else 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;
+        }
       }
     }
 
+    if (event.feature) {
+      const features = (event.feature as Feature)[isProvidedClusterFeature]
+        ? ((event.feature as Feature).get('features') as EventFeature[])
+        : [event.feature];
+
+      const promises = features.map(async (feature) => {
+        const layer = event.map.layerCollection.getByKey(feature[vcsLayerName]);
+        if (
+          layer?.featureProvider instanceof AbstractAttributeProvider ||
+          layer?.featureProvider instanceof CompositeFeatureProvider
+        ) {
+          await layer.featureProvider.augmentFeature(feature);
+        }
+      });
+      await Promise.all(promises);
+    }
+
     return event;
   }
 }