@vcmap/core 5.0.2 → 5.1.0-rc.1

package/src/layer/terrainHelpers.ts

@@ -7,6 +7,7 @@ import {
 import type { Coordinate } from 'ol/coordinate.js';
 import { getTransform } from 'ol/proj.js';
 import Projection, { wgs84Projection } from '../util/projection.js';
+import { getResourceOrUrl } from './cesium/resourceHelper.js';
 
 export type TerrainProviderOptions = {
   requestVertexNormals?: boolean;
@@ -15,16 +16,16 @@ export type TerrainProviderOptions = {
 
 const terrainProviders: Record<string, CesiumTerrainProvider> = {};
 
-/**
- * @param  url
- * @param  options
- */
 export async function getTerrainProviderForUrl(
   url: string,
   options: TerrainProviderOptions,
+  headers?: Record<string, string>,
 ): Promise<CesiumTerrainProvider> {
   if (!terrainProviders[url]) {
-    terrainProviders[url] = await CesiumTerrainProvider.fromUrl(url, options);
+    terrainProviders[url] = await CesiumTerrainProvider.fromUrl(
+      getResourceOrUrl(url, headers),
+      options,
+    );
     return terrainProviders[url];
   }
   let terrainProvider = terrainProviders[url];
@@ -34,12 +35,24 @@ export async function getTerrainProviderForUrl(
     (options.requestWaterMask !== undefined &&
       terrainProvider.requestWaterMask !== options.requestWaterMask)
   ) {
-    terrainProviders[url] = await CesiumTerrainProvider.fromUrl(url, options);
+    terrainProviders[url] = await CesiumTerrainProvider.fromUrl(
+      getResourceOrUrl(url, headers),
+      options,
+    );
     terrainProvider = terrainProviders[url];
   }
   return terrainProvider;
 }
 
+/**
+ * cleans the terrainProvider Cache, used for testing
+ */
+export function cleanCachedTerrainProviders(): void {
+  Object.keys(terrainProviders).forEach((key) => {
+    delete terrainProviders[key];
+  });
+}
+
 /**
  * changes input coordinate Array in place, new height can also be accessed by coordinates[x][2]
  * @param  terrainProvider

package/src/layer/terrainLayer.ts

@@ -78,10 +78,14 @@ class TerrainLayer extends Layer<TerrainCesiumImpl> {
   async getHeightForWGS84Coordinates(
     coords: Coordinate[],
   ): Promise<Coordinate[]> {
-    const terrainProvider = await getTerrainProviderForUrl(this.url, {
-      requestVertexNormals: this.requestVertexNormals,
-      requestWaterMask: this.requestWaterMask,
-    });
+    const terrainProvider = await getTerrainProviderForUrl(
+      this.url,
+      {
+        requestVertexNormals: this.requestVertexNormals,
+        requestWaterMask: this.requestWaterMask,
+      },
+      this.headers,
+    );
     return getHeightFromTerrainProvider(
       terrainProvider,
       coords,

package/src/layer/tileProvider/mvtTileProvider.ts

@@ -7,7 +7,7 @@ import TileProvider, {
   TileProviderOptions,
 } from './tileProvider.js';
 import { getURL } from './urlTemplateTileProvider.js';
-import { requestArrayBuffer } from '../../util/fetch.js';
+import { getInitForUrl, requestArrayBuffer } from '../../util/fetch.js';
 import { tileProviderClassRegistry } from '../../classRegistry.js';
 
 export type MVTTileProviderOptions = TileProviderOptions & {
@@ -68,12 +68,18 @@ class MVTTileProvider extends TileProvider {
     }
   }
 
-  async loader(x: number, y: number, z: number): Promise<Feature[]> {
+  async loader(
+    x: number,
+    y: number,
+    z: number,
+    headers?: Record<string, string>,
+  ): Promise<Feature[]> {
     const rectangle = this.tilingScheme.tileXYToRectangle(x, y, z);
     const url = getURL(this.url, x, y, z, rectangle, this.locale);
     const extent = rectangleToExtent(rectangle);
     const center = getCenter(extent);
-    const data = await requestArrayBuffer(url);
+    const init = getInitForUrl(this.url, headers);
+    const data = await requestArrayBuffer(url, init);
     const features = this._MVTFormat.readFeatures(data) as Feature[];
     const sx = (extent[2] - extent[0]) / 4096;
     const sy = -((extent[3] - extent[1]) / 4096);

package/src/layer/tileProvider/staticGeojsonTileProvider.ts

@@ -2,7 +2,7 @@ import type { GeoJSONObject } from 'ol/format/GeoJSON.js';
 import type { Feature } from 'ol/index.js';
 import { parseGeoJSON } from '../geojsonHelpers.js';
 import TileProvider, { TileProviderOptions } from './tileProvider.js';
-import { requestJson } from '../../util/fetch.js';
+import { getInitForUrl, requestJson } from '../../util/fetch.js';
 import { tileProviderClassRegistry } from '../../classRegistry.js';
 
 export type StaticGeoJSONTileProviderOptions = TileProviderOptions & {
@@ -36,8 +36,14 @@ class StaticGeoJSONTileProvider extends TileProvider {
   }
 
   // eslint-disable-next-line no-unused-vars
-  async loader(_x: number, _y: number, _z: number): Promise<Feature[]> {
-    const data = await requestJson<GeoJSONObject>(this.url);
+  async loader(
+    _x: number,
+    _y: number,
+    _z: number,
+    headers?: Record<string, string>,
+  ): Promise<Feature[]> {
+    const init = getInitForUrl(this.url, headers);
+    const data = await requestJson<GeoJSONObject>(this.url, init);
     const { features } = parseGeoJSON(data, { dynamicStyle: true });
     return features;
   }

package/src/layer/tileProvider/tileProvider.ts

@@ -363,6 +363,7 @@ class TileProvider extends VcsObject {
   private async _getRtreeForBaseTile(
     baseLevel: number,
     tileCenter: Cartographic,
+    headers?: Record<string, string>,
   ): Promise<TileProviderRtree | null> {
     const baseTile = this.tilingScheme.positionToTileXY(tileCenter, baseLevel);
     const baseTileCacheKey = this.getCacheKey(
@@ -372,7 +373,12 @@ class TileProvider extends VcsObject {
     );
     if (this.cache.has(baseLevel)) {
       if (!this.cache.get(baseLevel)!.containsKey(baseTileCacheKey)) {
-        const featuresPromise = this.loader(baseTile.x, baseTile.y, baseLevel);
+        const featuresPromise = this.loader(
+          baseTile.x,
+          baseTile.y,
+          baseLevel,
+          headers,
+        );
         // eslint-disable-next-line no-void
         void this._addTilePromiseToCache(
           featuresPromise,
@@ -388,12 +394,14 @@ class TileProvider extends VcsObject {
   /**
    * returns the features intersecting this coordinate. Depending on the resolution a buffer around the coordinate is requested.
    * The Buffer has the size of the resolution.
-   * @param  coordinate in mercator
-   * @param  resolution in m per pixel
+   * @param coordinate in mercator
+   * @param resolution in m per pixel
+   * @param headers optional request headers to be sent with the server request
    */
   async getFeaturesByCoordinate(
     coordinate: Coordinate,
     resolution: number,
+    headers?: Record<string, string>,
   ): Promise<Feature[]> {
     const extent = createOrUpdateFromCoordinate(coordinate);
     buffer(extent, resolution, extent);
@@ -406,7 +414,11 @@ class TileProvider extends VcsObject {
       resolution,
       cartographic.latitude,
     );
-    const rtree = await this._getRtreeForBaseTile(baseLevel, cartographic);
+    const rtree = await this._getRtreeForBaseTile(
+      baseLevel,
+      cartographic,
+      headers,
+    );
     if (rtree) {
       const features = rtree
         .search({
@@ -423,20 +435,26 @@ class TileProvider extends VcsObject {
 
   /**
    * returns features for the requested Tile.
-   * @param  x
-   * @param  y
-   * @param  level - if the level is not a base level, will use the closest match
+   * @param x
+   * @param y
+   * @param level - if the level is not a base level, will use the closest match
+   * @param headers optional request headers to be sent with the server request
    */
   async getFeaturesForTile(
     x: number,
     y: number,
     level: number,
+    headers?: Record<string, string>,
   ): Promise<Feature[]> {
     const rectangle = this.tilingScheme.tileXYToRectangle(x, y, level);
     const tileCenter = Rectangle.center(rectangle);
     const baseLevel = this.getBaseLevel(level);
     if (baseLevel != null) {
-      const rtree = await this._getRtreeForBaseTile(baseLevel, tileCenter);
+      const rtree = await this._getRtreeForBaseTile(
+        baseLevel,
+        tileCenter,
+        headers,
+      );
       if (rtree) {
         if (level === baseLevel) {
           return rtree.all().map((item) => item.value);
@@ -462,21 +480,29 @@ class TileProvider extends VcsObject {
       const childNorth = x * 2;
       const childWest = y * 2;
       return [
-        ...(await this.getFeaturesForTile(childNorth, childWest, childLevel)),
+        ...(await this.getFeaturesForTile(
+          childNorth,
+          childWest,
+          childLevel,
+          headers,
+        )),
         ...(await this.getFeaturesForTile(
           childNorth + 1,
           childWest,
           childLevel,
+          headers,
         )),
         ...(await this.getFeaturesForTile(
           childNorth + 1,
           childWest + 1,
           childLevel,
+          headers,
         )),
         ...(await this.getFeaturesForTile(
           childNorth,
           childWest + 1,
           childLevel,
+          headers,
         )),
       ];
     }
@@ -485,12 +511,14 @@ class TileProvider extends VcsObject {
 
   /**
    * Retrieves all features which intersect the given extent. Will load all intersecting tiles.
-   * @param  extent
-   * @param  level - Optional level to request. Will use highest level if omitted. If the provided level is not a base level, will use the closest match.
+   * @param extent
+   * @param level - Optional level to request. Will use highest level if omitted. If the provided level is not a base level, will use the closest match.
+   * @param headers Optional request headers to be sent with the server request
    */
   async getFeaturesForExtent(
     extent: Extent,
     level?: number,
+    headers?: Record<string, string>,
   ): Promise<Feature[]> {
     let usedLevel = level != null ? level : this.baseLevels[0];
     usedLevel = this.getBaseLevel(usedLevel) as number;
@@ -512,7 +540,9 @@ class TileProvider extends VcsObject {
     }
 
     const features = await Promise.all(
-      tileCoordinates.map(([x, y]) => this.getFeaturesForTile(x, y, usedLevel)),
+      tileCoordinates.map(([x, y]) =>
+        this.getFeaturesForTile(x, y, usedLevel, headers),
+      ),
     );
     const mercatorExtent =
       extent.getCoordinatesInProjection(mercatorProjection);
@@ -559,7 +589,12 @@ class TileProvider extends VcsObject {
    *   });
    */
   // eslint-disable-next-line class-methods-use-this,no-unused-vars
-  loader(_x: number, _y: number, _z: number): Promise<Feature[]> {
+  loader(
+    _x: number,
+    _y: number,
+    _z: number,
+    _headers?: Record<string, string>,
+  ): Promise<Feature[]> {
     return Promise.resolve([]);
   }
 
@@ -589,6 +624,7 @@ class TileProvider extends VcsObject {
     if (defaultOptions.allowTileAggregation !== this.allowTileAggregation) {
       config.allowTileAggregation = this.allowTileAggregation;
     }
+
     return config;
   }
 

package/src/layer/tileProvider/urlTemplateTileProvider.ts

@@ -3,7 +3,7 @@ import { Math as CesiumMath, Rectangle } from '@vcmap-cesium/engine';
 import type { Feature } from 'ol/index.js';
 import { parseGeoJSON } from '../geojsonHelpers.js';
 import TileProvider, { TileProviderOptions } from './tileProvider.js';
-import { requestJson } from '../../util/fetch.js';
+import { getInitForUrl, requestJson } from '../../util/fetch.js';
 import { tileProviderClassRegistry } from '../../classRegistry.js';
 
 export type URLTemplateTileProviderOptions = TileProviderOptions & {
@@ -94,10 +94,17 @@ class URLTemplateTileProvider extends TileProvider {
     }
   }
 
-  async loader(x: number, y: number, z: number): Promise<Feature[]> {
+  async loader(
+    x: number,
+    y: number,
+    z: number,
+    headers?: Record<string, string>,
+  ): Promise<Feature[]> {
     const rectangle = this.tilingScheme.tileXYToRectangle(x, y, z);
     const url = getURL(this.url, x, y, z, rectangle, this.locale);
-    const data = await requestJson<GeoJSONObject>(url);
+
+    const init = getInitForUrl(this.url, headers);
+    const data = await requestJson<GeoJSONObject>(url, init);
     const { features } = parseGeoJSON(data, { dynamicStyle: true });
     return features;
   }

package/src/layer/vectorLayer.ts

@@ -16,7 +16,7 @@ import type {
 } from '@vcmap-cesium/engine';
 
 import { v4 as uuidv4 } from 'uuid';
-import { check } from '@vcsuite/check';
+import { check, oneOf } from '@vcsuite/check';
 import { parseBoolean } from '@vcsuite/parsers';
 import Projection, {
   getDefaultProjection,
@@ -78,7 +78,12 @@ export type VectorOptions = FeatureLayerOptions & {
 
 export type VectorGeometryFactoryType = {
   getCoordinates(geom: SimpleGeometry[]): Coordinate[];
-  getGeometryOptions(geom: SimpleGeometry, num: number): unknown;
+  getGeometryOptions(
+    geom: SimpleGeometry,
+    num: number,
+    perPositionHeight: boolean,
+    groundLevelOrMinHeight: number,
+  ): unknown;
   createSolidGeometries(
     obj: unknown,
     num: number,
@@ -101,11 +106,6 @@ export type VectorGeometryFactoryType = {
     style: Style,
   ): GroundPolylineGeometry[];
   createLineGeometries(obj: unknown, style: Style): PolylineGeometry[];
-  createLineGeometries(
-    obj: unknown,
-    style: Style,
-    groundLevel?: number,
-  ): PolylineGeometry[];
 };
 
 export type VectorHeightInfo = {
@@ -415,7 +415,7 @@ class VectorLayer
    * sets the highlightstyle of this layer
    */
   setHighlightStyle(style: Style | StyleFunction | VectorStyleItem): void {
-    check(style, [Style, VectorStyleItem, Function]);
+    check(style, oneOf(Style, VectorStyleItem, Function));
     if (style instanceof VectorStyleItem) {
       this.highlightStyle = style;
     } else {
@@ -500,7 +500,7 @@ class VectorLayer
    * feature geometries are always in EPSG 3857 mercator coordinate system
    */
   getFeaturesById(ids: (string | number)[]): Feature[] {
-    check(ids, [[String, Number]]);
+    check(ids, [oneOf(String, Number)]);
     return ids
       .map((id) => this.getFeatureById(id))
       .filter((f) => f != null) as Feature[];

package/src/layer/vectorProperties.ts

@@ -10,7 +10,7 @@ import {
   NearFarScalar,
   type SphereGeometry,
 } from '@vcmap-cesium/engine';
-import { check, checkMaybe } from '@vcsuite/check';
+import { check, maybe, ofEnum } from '@vcsuite/check';
 import type { Coordinate } from 'ol/coordinate.js';
 import type { Color } from 'ol/color.js';
 import type { ColorLike } from 'ol/colorlike.js';
@@ -24,10 +24,12 @@ import { getLogger as getLoggerByName, type Logger } from '@vcsuite/logger';
 import VcsEvent from '../vcsEvent.js';
 import { DeclarativeStyleItemOptions } from '../style/declarativeStyleItem.js';
 import { VectorStyleItemOptions } from '../style/vectorStyleItem.js';
+import type { FlightInstanceMeta } from '../util/flight/flightInstance.js';
 
 function getLogger(): Logger {
   return getLoggerByName('VectorProperties');
 }
+
 export enum PrimitiveOptionsType {
   CYLINDER = 'cylinder',
   SPHERE = 'sphere',
@@ -72,11 +74,18 @@ export function vectorPropertiesOfType<T extends PrimitiveOptionsType>(
   return options.type === type;
 }
 
+export type AltitudeModeType =
+  | 'absolute'
+  | 'relativeToGround'
+  | 'clampToGround';
+
+export type ClassificationTypeType = 'both' | 'terrain' | 'cesium3DTile';
+
 export type VectorPropertiesOptions = {
   /**
    * (3D) Either "relativeToGround", "clampToGround" or 'absolute'
    */
-  altitudeMode?: string;
+  altitudeMode?: AltitudeModeType;
   /**
    * if the features are pickable
    */
@@ -84,7 +93,7 @@ export type VectorPropertiesOptions = {
   /**
    * (3D) the cesium classification type for this layer. one of 'both', 'terrain' or 'cesium3DTile'
    */
-  classificationType?: string;
+  classificationType?: ClassificationTypeType;
   /**
    * (3D) Array with 4 numbers by which features are being scaled based on distance see <a href="https://cesium.com/docs/cesiumjs-ref-doc/Billboard.html#scaleByDistance"> here </a>
    */
@@ -152,7 +161,7 @@ export type VcsMeta = VectorPropertiesOptions & {
   style?: VectorStyleItemOptions | DeclarativeStyleItemOptions;
   embeddedIcons?: string[];
   screenSpaceError?: number;
-  flightOptions?: unknown;
+  flightOptions?: FlightInstanceMeta;
   baseUrl?: string;
   /**
    * the layers properties bag
@@ -181,13 +190,16 @@ export type VectorPropertiesPrimitive = VectorPropertiesBaseOptions & {
  */
 export const vcsMetaVersion = '2.1';
 
-export const AltitudeModeCesium = {
+export const AltitudeModeCesium: Record<AltitudeModeType, HeightReference> = {
   clampToGround: HeightReference.CLAMP_TO_GROUND,
   absolute: HeightReference.NONE,
   relativeToGround: HeightReference.RELATIVE_TO_GROUND,
 };
 
-export const ClassificationTypeCesium = {
+export const ClassificationTypeCesium: Record<
+  ClassificationTypeType,
+  ClassificationType
+> = {
   both: ClassificationType.BOTH,
   cesium3DTile: ClassificationType.CESIUM_3D_TILE,
   terrain: ClassificationType.TERRAIN,
@@ -246,19 +258,27 @@ export function parseStoreyHeights(
   return defaultStoreyHeights;
 }
 
-export function getAltitudeModeOptions(altitudeMode: HeightReference): string {
-  for (const [key, mode] of Object.entries(AltitudeModeCesium)) {
+export function getAltitudeModeOptions(
+  altitudeMode: HeightReference,
+): AltitudeModeType {
+  for (const [key, mode] of Object.entries(AltitudeModeCesium) as [
+    AltitudeModeType,
+    HeightReference,
+  ][]) {
     if (mode === altitudeMode) {
       return key;
     }
   }
-  throw new Error(`Unkown altitude mode ${altitudeMode}`);
+  throw new Error(`Unknown altitude mode ${altitudeMode}`);
 }
 
 export function getClassificationTypeOptions(
   classificationType?: ClassificationType,
-): string | undefined {
-  for (const [key, mode] of Object.entries(ClassificationTypeCesium)) {
+): ClassificationTypeType | undefined {
+  for (const [key, mode] of Object.entries(ClassificationTypeCesium) as [
+    ClassificationTypeType,
+    ClassificationType,
+  ][]) {
     if (mode === classificationType) {
       return key;
     }
@@ -484,7 +504,7 @@ class VectorProperties {
 
   set altitudeMode(altitudeMode: HeightReference) {
     if (altitudeMode !== this._altitudeMode) {
-      check(altitudeMode, Object.values(HeightReference));
+      check(altitudeMode, ofEnum(HeightReference));
       this._altitudeMode = altitudeMode;
       this.propertyChanged.raiseEvent(['altitudeMode']);
     }
@@ -521,7 +541,7 @@ class VectorProperties {
 
   set classificationType(classificationType: ClassificationType | undefined) {
     if (classificationType !== this._classificationType) {
-      checkMaybe(classificationType, Object.values(ClassificationType));
+      check(classificationType, maybe(ofEnum(ClassificationType)));
       this._classificationType = classificationType;
       this.propertyChanged.raiseEvent(['classificationType']);
     }
@@ -541,7 +561,7 @@ class VectorProperties {
 
   set scaleByDistance(value: NearFarScalar | undefined) {
     if (!NearFarScalar.equals(value, this._scaleByDistance)) {
-      checkMaybe(value, NearFarScalar);
+      check(value, maybe(NearFarScalar));
       this._scaleByDistance = value;
       this.propertyChanged.raiseEvent(['scaleByDistance']);
     }
@@ -560,7 +580,7 @@ class VectorProperties {
 
   set eyeOffset(value: Cartesian3 | undefined) {
     if (!Cartesian3.equals(this.eyeOffset, value)) {
-      checkMaybe(value, Cartesian3);
+      check(value, maybe(Cartesian3));
       this._eyeOffset = value;
       this.propertyChanged.raiseEvent(['eyeOffset']);
     }
@@ -624,7 +644,7 @@ class VectorProperties {
 
   set groundLevel(value: number | undefined) {
     if (value !== this._groundLevel) {
-      checkMaybe(value, Number);
+      check(value, maybe(Number));
       this._groundLevel = value;
       this.propertyChanged.raiseEvent(['groundLevel']);
     }
@@ -731,7 +751,7 @@ class VectorProperties {
   }
 
   set modelUrl(value: string | undefined) {
-    checkMaybe(value, String);
+    check(value, maybe(String));
 
     if (this._modelUrl !== value) {
       this._modelUrl = value;
@@ -855,7 +875,7 @@ class VectorProperties {
   }
 
   set modelOptions(modelOptions: Record<string, unknown> | undefined) {
-    checkMaybe(modelOptions, Object);
+    check(modelOptions, maybe(Object));
 
     if (this._modelOptions !== modelOptions) {
       this._modelOptions = modelOptions;
@@ -885,7 +905,7 @@ class VectorProperties {
   }
 
   set modelAutoScale(value: boolean) {
-    checkMaybe(value, Boolean);
+    check(value, maybe(Boolean));
 
     const booleanValue = !!value;
     if (this._modelAutoScale !== booleanValue) {
@@ -906,7 +926,7 @@ class VectorProperties {
   }
 
   set baseUrl(value: string | undefined) {
-    checkMaybe(value, String);
+    check(value, maybe(String));
 
     if (this._baseUrl !== value) {
       this._baseUrl = value;
@@ -924,7 +944,7 @@ class VectorProperties {
   }
 
   set primitiveOptions(value: VectorPropertiesPrimitiveOptions | undefined) {
-    checkMaybe(value, Object);
+    check(value, maybe(Object));
 
     if (this._primitiveOptions !== value) {
       this._primitiveOptions = value;
@@ -1282,11 +1302,15 @@ class VectorProperties {
   /**
    * The common vector properties for the input features.
    * @param features Features for which the vector property values should be returned.
-   * @returns The common vector properties for the features. When a/all feature(s) does not has a property set, the layer or, if not set, the default value is returned. If features have different values for a property, the property key is not added to the returned obeject.
+   * @returns The common vector properties for the features. When a/all feature(s) does not has a property set, the layer or, if not set, the default value is returned. If features have different values for a property, the property key is not added to the returned obeject. If feature array is empty, an empty object is returned.
    */
   getValuesForFeatures(features: Feature[]): VectorPropertiesOptions {
     const values: VectorPropertiesOptions = {};
 
+    if (!features.length) {
+      return values;
+    }
+
     /**
      * Checks if all the values of the array are equal using fast-deep-equal.
      * @param propertyValues An array of values for a specific property from different features.

package/src/layer/wfsLayer.ts

@@ -2,7 +2,7 @@ import WFSFormat from 'ol/format/WFS.js';
 import VectorLayer, { VectorOptions } from './vectorLayer.js';
 import Projection from '../util/projection.js';
 import { layerClassRegistry } from '../classRegistry.js';
-import { requestUrl } from '../util/fetch.js';
+import { getInitForUrl, requestUrl } from '../util/fetch.js';
 
 export type WFSOptions = VectorOptions & {
   /**
@@ -125,13 +125,16 @@ class WFSLayer extends VectorLayer {
         ...this.getFeaturesOptions,
       });
       const postData = new XMLSerializer().serializeToString(requestDocument);
-      this._dataFetchedPromise = requestUrl(this.url, {
-        method: 'POST',
-        headers: {
+      const init = getInitForUrl(this.url, this.headers);
+      init.method = 'POST';
+      init.body = postData;
+      init.headers = {
+        ...init.headers,
+        ...{
           'Content-Type': 'application/text+xml',
         },
-        body: postData,
-      })
+      };
+      this._dataFetchedPromise = requestUrl(this.url, init)
         .then((response) => response.text())
         .then((data) => this._parseWFSData(data))
         .catch((err) => {