@vcmap/core 5.0.2 → 5.1.0-rc.1

package/src/layer/wmsHelpers.ts

@@ -1,5 +1,11 @@
+import { TrustedServers } from '@vcmap-cesium/engine';
+import { getLogger } from '@vcsuite/logger';
 import type { Size } from 'ol/size.js';
 import TileWMS, { type Options as TileWMSOptions } from 'ol/source/TileWMS.js';
+import ImageWMS, {
+  type Options as ImageWMSOptions,
+} from 'ol/source/ImageWMS.js';
+
 import { getTopLeft, getWidth } from 'ol/extent.js';
 import TileGrid, {
   type Options as TileGridOptions,
@@ -8,6 +14,8 @@ import { mercatorProjection, wgs84Projection } from '../util/projection.js';
 import { isSameOrigin } from '../util/urlHelpers.js';
 import type Extent from '../util/extent.js';
 import { TilingScheme } from './rasterLayer.js';
+import { getTileLoadFunction } from './openlayers/loadFunctionHelpers.js';
+import { getInitForUrl, requestObjectUrl } from '../util/fetch.js';
 
 export type WMSSourceOptions = {
   url: string;
@@ -18,9 +26,23 @@ export type WMSSourceOptions = {
   extent?: Extent;
   parameters: Record<string, string>;
   version: string;
+  headers?: Record<string, string>;
 };
 
-// eslint-disable-next-line import/prefer-default-export
+export function getProjectionFromWMSSourceOptions(
+  tilingSchema: TilingScheme,
+  version: string,
+): string {
+  if (tilingSchema === 'geographic') {
+    if (version === '1.3.0') {
+      return 'CRS:84';
+    } else {
+      return 'EPSG:4326';
+    }
+  }
+  return 'EPSG:3857';
+}
+
 export function getWMSSource(options: WMSSourceOptions): TileWMS {
   const projection =
     options.tilingSchema === 'geographic'
@@ -55,18 +77,64 @@ export function getWMSSource(options: WMSSourceOptions): TileWMS {
     url: options.url,
     tileGrid: new TileGrid(tilingOptions),
     params: options.parameters,
+    projection: getProjectionFromWMSSourceOptions(
+      options.tilingSchema,
+      options.version,
+    ),
   };
-  if (!isSameOrigin(options.url)) {
+
+  if (TrustedServers.contains(options.url)) {
+    sourceOptions.crossOrigin = 'use-credentials';
+  } else if (!isSameOrigin(options.url)) {
     sourceOptions.crossOrigin = 'anonymous';
   }
-  if (options.tilingSchema === 'geographic') {
-    if (options.version === '1.3.0') {
-      sourceOptions.projection = 'CRS:84';
-    } else {
-      sourceOptions.projection = 'EPSG:4326';
-    }
-  } else {
-    sourceOptions.projection = 'EPSG:3857';
+  if (options.headers) {
+    sourceOptions.tileLoadFunction = getTileLoadFunction(options.headers);
   }
   return new TileWMS(sourceOptions);
 }
+
+export function getImageWMSSource(options: {
+  url: string;
+  parameters: Record<string, string>;
+  tilingSchema: TilingScheme;
+  version: string;
+  headers?: Record<string, string>;
+}): ImageWMS {
+  const sourceOptions: ImageWMSOptions = {
+    url: options.url,
+    params: options.parameters,
+    projection: getProjectionFromWMSSourceOptions(
+      options.tilingSchema,
+      options.version,
+    ),
+  };
+
+  if (TrustedServers.contains(options.url)) {
+    sourceOptions.crossOrigin = 'use-credentials';
+  } else if (!isSameOrigin(options.url)) {
+    sourceOptions.crossOrigin = 'anonymous';
+  }
+
+  if (options.headers) {
+    sourceOptions.imageLoadFunction = function imageLoadFunction(
+      image,
+      src,
+    ): void {
+      const img = image.getImage() as HTMLImageElement;
+      const init = getInitForUrl(src, options.headers);
+      requestObjectUrl(src, init)
+        .then((blobUrl) => {
+          img.src = blobUrl;
+          img.onload = (): void => {
+            URL.revokeObjectURL(blobUrl);
+          };
+        })
+        .catch(() => {
+          getLogger('ImageWMSSource').error(`Could not load image: ${src}`);
+        });
+    };
+  }
+
+  return new ImageWMS(sourceOptions);
+}

package/src/layer/wmsLayer.ts

@@ -1,4 +1,4 @@
-import { check } from '@vcsuite/check';
+import { check, oneOf } from '@vcsuite/check';
 import { parseBoolean } from '@vcsuite/parsers';
 import type { Size } from 'ol/size.js';
 
@@ -22,6 +22,7 @@ export type WMSImplementationOptions = RasterLayerImplementationOptions & {
   highResolution: boolean;
   tileSize: import('ol/size.js').Size;
   version: string;
+  singleImage2d: boolean;
 };
 
 export type WMSOptions = RasterLayerOptions & {
@@ -50,6 +51,10 @@ export type WMSOptions = RasterLayerOptions & {
    * use higher resolution images (sofar only in 3D)
    */
   highResolution?: boolean;
+  /**
+   * Use a single image in 2D
+   */
+  singleImage2d?: boolean;
 };
 
 /**
@@ -81,6 +86,8 @@ class WMSLayer extends RasterLayer<WmsCesiumImpl | WmsOpenlayersImpl> {
 
   highResolution: boolean;
 
+  singleImage2d: boolean;
+
   private _featureInfoOptions: Partial<WMSFeatureProviderOptions> | undefined;
 
   /**
@@ -127,6 +134,7 @@ class WMSLayer extends RasterLayer<WmsCesiumImpl | WmsOpenlayersImpl> {
     this._featureInfoOptions =
       options.featureInfo || defaultOptions.featureInfo;
     this._supportedMaps = [CesiumMap.className, OpenlayersMap.className];
+    this.singleImage2d = parseBoolean(options.singleImage2d, false);
   }
 
   initialize(): Promise<void> {
@@ -171,6 +179,7 @@ class WMSLayer extends RasterLayer<WmsCesiumImpl | WmsOpenlayersImpl> {
       parameters: this.parameters,
       highResolution: this.highResolution,
       tileSize: this.tileSize,
+      singleImage2d: this.singleImage2d,
     };
   }
 
@@ -190,7 +199,7 @@ class WMSLayer extends RasterLayer<WmsCesiumImpl | WmsOpenlayersImpl> {
    * @param  layers - a layer name or an array of layer names
    */
   async setLayers(layers: string | string[]): Promise<void> {
-    check(layers, [String, [String]]);
+    check(layers, oneOf(String, [String]));
     const layersArray = Array.isArray(layers) ? layers : [layers];
     this.parameters.LAYERS = layersArray.join(',');
     await this.forceRedraw();

package/src/map/cameraLimiter.ts

@@ -1,3 +1,4 @@
+import deepEqual from 'fast-deep-equal';
 import {
   Camera,
   Cartographic,
@@ -6,7 +7,7 @@ import {
   sampleTerrain,
   sampleTerrainMostDetailed,
 } from '@vcmap-cesium/engine';
-import { checkMaybe } from '@vcsuite/check';
+import { check, maybe } from '@vcsuite/check';
 import { parseInteger, parseNumber, parseEnumValue } from '@vcsuite/parsers';
 import {
   getTerrainProviderForUrl,
@@ -26,6 +27,10 @@ export type CameraLimiterOptions = {
    *  required if mode is distance.
    */
   terrainUrl?: string;
+  /**
+   * if mode is distance this can be used to send headers with each request to the terrainUrl
+   */
+  terrainRequestHeaders?: Record<string, string>;
   /**
    * @default 'height'
    */
@@ -53,6 +58,7 @@ class CameraLimiter {
     return {
       mode: CameraLimiterMode.HEIGHT,
       terrainUrl: undefined,
+      terrainRequestHeaders: undefined,
       limit: 200,
       level: 12,
     };
@@ -80,6 +86,8 @@ class CameraLimiter {
    */
   lastCheckedPosition = new Cartographic();
 
+  terrainRequestHeaders?: Record<string, string>;
+
   /**
    * last updated terrain height
    */
@@ -101,6 +109,7 @@ class CameraLimiter {
       options.level === null
         ? null
         : parseInteger(options.level, defaultOptions.level as number);
+    this.terrainRequestHeaders = options.terrainRequestHeaders;
   }
 
   /**
@@ -111,7 +120,7 @@ class CameraLimiter {
   }
 
   set terrainUrl(url: string | undefined) {
-    checkMaybe(url, String);
+    check(url, maybe(String));
 
     if (this._terrainUrl !== url) {
       this._terrainUrl = url;
@@ -124,6 +133,7 @@ class CameraLimiter {
     const terrainProvider = await getTerrainProviderForUrl(
       this.terrainUrl as string,
       {},
+      this.terrainRequestHeaders,
     );
     if (
       this.level &&
@@ -140,6 +150,7 @@ class CameraLimiter {
     const terrainProvider = await getTerrainProviderForUrl(
       this.terrainUrl as string,
       {},
+      this.terrainRequestHeaders,
     );
     return sampleTerrainMostDetailed(terrainProvider, [cameraCartographic]);
   }
@@ -222,6 +233,14 @@ class CameraLimiter {
     if (this.level !== defaultOptions.level) {
       config.level = this.level;
     }
+    if (
+      !deepEqual(
+        this.terrainRequestHeaders,
+        defaultOptions.terrainRequestHeaders,
+      )
+    ) {
+      config.terrainRequestHeaders = this.terrainRequestHeaders;
+    }
     return config;
   }
 }

package/src/map/cesiumMap.ts

@@ -36,10 +36,11 @@ import {
   type EntityCluster,
   type DataSource,
   type Visualizer,
+  type ShadowMap,
 } from '@vcmap-cesium/engine';
 import type { Coordinate } from 'ol/coordinate.js';
 
-import { checkMaybe } from '@vcsuite/check';
+import { check, maybe } from '@vcsuite/check';
 import { parseBoolean, parseInteger, parseNumber } from '@vcsuite/parsers';
 import VcsMap, { type VcsMapOptions } from './vcsMap.js';
 import Viewpoint from '../util/viewpoint.js';
@@ -55,6 +56,7 @@ import CameraLimiter, { CameraLimiterOptions } from './cameraLimiter.js';
 import { mapClassRegistry } from '../classRegistry.js';
 import type LayerCollection from '../util/layerCollection.js';
 import type Layer from '../layer/layer.js';
+import VcsEvent from '../vcsEvent.js';
 
 export type CesiumMapOptions = VcsMapOptions & {
   /**
@@ -327,6 +329,18 @@ class CesiumMap extends VcsMap<CesiumVisualisationType> {
 
   defaultJDate: JulianDate;
 
+  /**
+   * The defaultShadowMap which is created when calling the constructor of the CesiumWidet in {@link initialize}. This is a reference, not a clone.
+   */
+  private _defaultShadowMap: ShadowMap | null;
+
+  /**
+   * A cache of the shadowMap that is set, before {@link initialize} is called. It is applied as soon the instance is initialized.
+   */
+  private _initialShadowMap: ShadowMap | null;
+
+  shadowMapChanged: VcsEvent<ShadowMap>;
+
   webGLaa: boolean;
 
   globeColor: Color;
@@ -383,6 +397,12 @@ class CesiumMap extends VcsMap<CesiumVisualisationType> {
 
     this.defaultJDate = JulianDate.fromDate(new Date(2014, 6, 20, 13, 0, 0, 0));
 
+    this._defaultShadowMap = null;
+
+    this._initialShadowMap = null;
+
+    this.shadowMapChanged = new VcsEvent();
+
     this.webGLaa = parseBoolean(options.webGLaa, defaultOptions.webGLaa);
 
     this.useOriginalCesiumShader = parseBoolean(
@@ -459,7 +479,7 @@ class CesiumMap extends VcsMap<CesiumVisualisationType> {
   }
 
   set cameraLimiter(limiter: CameraLimiter | null) {
-    checkMaybe(limiter, CameraLimiter);
+    check(limiter, maybe(CameraLimiter));
 
     if (this._cameraLimiter !== limiter) {
       this._cameraLimiter = limiter;
@@ -732,6 +752,13 @@ class CesiumMap extends VcsMap<CesiumVisualisationType> {
           },
         ),
       );
+
+      this._defaultShadowMap = this._cesiumWidget.scene.shadowMap;
+
+      if (this._initialShadowMap) {
+        this.setShadowMap(this._initialShadowMap);
+        this._initialShadowMap = null;
+      }
     }
     return Promise.resolve();
   }
@@ -1023,6 +1050,40 @@ class CesiumMap extends VcsMap<CesiumVisualisationType> {
     }
   }
 
+  /**
+   * Sets a shadow map on the scene of the cesiumMaps cesiumWidget. Raises an event if the shadow map changes. This function should be used to set the shadowMap instead of setting it directly on the scene.
+   * @param shadowMap The shadowMap to assign to the scene of the cesium widget.
+   */
+  setShadowMap(shadowMap: ShadowMap): void {
+    if (!shadowMap) {
+      return;
+    }
+
+    if (!this._cesiumWidget) {
+      this._initialShadowMap = shadowMap;
+      return;
+    }
+
+    const { scene } = this._cesiumWidget;
+
+    if (scene.shadowMap !== shadowMap) {
+      scene.shadowMap = shadowMap;
+      this.shadowMapChanged.raiseEvent(shadowMap);
+    }
+  }
+
+  /**
+   * Sets the default shadow map.
+   */
+  setDefaultShadowMap(): void {
+    if (!this._cesiumWidget || !this._defaultShadowMap) {
+      this._initialShadowMap = null;
+      return;
+    }
+
+    this.setShadowMap(this._defaultShadowMap);
+  }
+
   /**
    * returns the cesium Widget Object
    */
@@ -1380,6 +1441,10 @@ class CesiumMap extends VcsMap<CesiumVisualisationType> {
       this._cesiumWidget = null;
     }
 
+    this._initialShadowMap = null;
+    this._defaultShadowMap = null;
+    this.shadowMapChanged.destroy();
+
     super.destroy();
   }
 }

package/src/map/vcsMap.ts

@@ -3,7 +3,7 @@ import type { MapEvent as OLMapEvent } from 'ol';
 import type { Layer as OLLayer } from 'ol/layer.js';
 import type { Coordinate } from 'ol/coordinate.js';
 
-import { check, checkMaybe } from '@vcsuite/check';
+import { check, maybe, oneOf } from '@vcsuite/check';
 import VcsObject, { VcsObjectOptions } from '../vcsObject.js';
 import LayerCollection from '../util/layerCollection.js';
 import MapState from './mapState.js';
@@ -256,7 +256,7 @@ class VcsMap<
    * Sets the map target.
    */
   setTarget(target: string | HTMLElement | null): void {
-    checkMaybe(target, [String, HTMLElement]);
+    check(target, maybe(oneOf(String, HTMLElement)));
 
     if (this._target) {
       this._target.removeChild(this.mapElement);

package/src/oblique/helpers.ts

@@ -1,5 +1,6 @@
 /* eslint no-underscore-dangle: ["error", { "allow": ["_listeners", "_scopes", "_toRemove"] }] */
 /* eslint-disable no-continue */
+import { getLogger } from '@vcsuite/logger';
 import {
   boundingExtent,
   getBottomLeft,
@@ -18,6 +19,7 @@ import Projection, {
   wgs84Projection,
 } from '../util/projection.js';
 import type ObliqueImage from './obliqueImage.js';
+import { isSameOrigin } from '../util/urlHelpers.js';
 
 let scratchCartesian2A = new Cartesian2();
 let scratchCartesian2B = new Cartesian2();
@@ -423,7 +425,7 @@ export type ImageTransformationOptions = {
  * Always returns a Promise. When the input coordinates contain a height, it will use this height to compute the image coordinates
  * When not, it will try to get the terrainHeight in case a terrain is defined and use the height from there, to compute the image coordinates
  * @param  image
- * @param  worldCoordinate if not in web mercatpr, specify data-projection in options
+ * @param  worldCoordinate if not in web mercator, specify data-projection in options
  * @param  options
  */
 export function transformToImage(
@@ -614,16 +616,6 @@ export async function transformFromImage(
 }
 
 export function hasSameOrigin(url: string): boolean {
-  const windowUrl = new URL(window.location.href);
-  const parsedUrl = new URL(url, window.location.href);
-
-  if (parsedUrl.protocol === 'data:') {
-    return true;
-  }
-
-  return (
-    windowUrl.origin === parsedUrl.origin &&
-    windowUrl.port === parsedUrl.port &&
-    windowUrl.protocol === parsedUrl.protocol
-  );
+  getLogger('hasSameOrigin').deprecate('hasSameOrigin', 'isSameOrigin');
+  return isSameOrigin(url);
 }

package/src/oblique/obliqueCollection.ts

@@ -64,6 +64,7 @@ export type ObliqueVersion = {
 
 export type ObliqueDataSetTerrainProviderOptions = TerrainProviderOptions & {
   url: string;
+  headers?: Record<string, string>;
 };
 
 export type ObliqueCollectionOptions = VcsObjectOptions & {
@@ -280,6 +281,7 @@ class ObliqueCollection extends VcsObject {
         dataSetOptions.url,
         dataSetOptions.projection,
         dataSetOptions.terrainProvider,
+        dataSetOptions.headers,
       );
     }
     dataSet.imagesLoaded.addEventListener(({ images, tileCoordinate }) => {

package/src/oblique/obliqueDataSet.ts

@@ -13,7 +13,7 @@ import {
 import VcsEvent from '../vcsEvent.js';
 import { getTerrainProviderForUrl } from '../layer/terrainHelpers.js';
 import Projection, { ProjectionOptions } from '../util/projection.js';
-import { requestJson } from '../util/fetch.js';
+import { getInitForUrl, requestJson } from '../util/fetch.js';
 import type ObliqueImage from './obliqueImage.js';
 import type {
   ObliqueDataSetTerrainProviderOptions,
@@ -31,6 +31,7 @@ export type ObliqueDataSetOptions = {
   url: string;
   projection?: ProjectionOptions;
   terrainProvider?: ObliqueDataSetTerrainProviderOptions;
+  headers?: Record<string, string>;
 };
 
 export enum DataState {
@@ -85,12 +86,15 @@ class ObliqueDataSet {
 
   private _loadingPromise: Promise<void> | undefined = undefined;
 
+  private _headers?: Record<string, string>;
+
   copyright: CopyrightOptions | undefined = undefined;
 
   constructor(
     url: string,
     projection?: Projection | ProjectionOptions,
     terrainProviderOptions?: ObliqueDataSetTerrainProviderOptions,
+    headers?: Record<string, string>,
   ) {
     this.url = url;
     if (!/\.json$/.test(this.url)) {
@@ -108,6 +112,8 @@ class ObliqueDataSet {
     this._terrainProviderOptions = terrainProviderOptions
       ? { ...terrainProviderOptions }
       : undefined;
+
+    this._headers = structuredClone(headers);
   }
 
   /**
@@ -131,7 +137,8 @@ class ObliqueDataSet {
   async load(): Promise<void> {
     if (!this._loadingPromise) {
       this._state = DataState.LOADING;
-      this._loadingPromise = requestJson<ObliqueImageJson>(this.url)
+      const init = getInitForUrl(this.url, this._headers);
+      this._loadingPromise = requestJson<ObliqueImageJson>(this.url, init)
         .then((data) => {
           return this._initialize(data);
         })
@@ -174,6 +181,7 @@ class ObliqueDataSet {
       this._terrainProvider = await getTerrainProviderForUrl(
         this._terrainProviderOptions.url,
         terrainProviderOptions,
+        this._terrainProviderOptions.headers,
       );
     }
     this._parseMetaData(json);
@@ -186,6 +194,7 @@ class ObliqueDataSet {
       this.baseUrl,
       this.projection,
       this._terrainProvider,
+      this._headers,
     );
     const { version, buildNumber } = getVersionFromImageJson(json);
 
@@ -304,8 +313,10 @@ class ObliqueDataSet {
     }
 
     this._tiles.set(stringTileCoordinates, DataState.LOADING);
+    const init = getInitForUrl(this.url, this._headers);
     const promise = requestJson<ObliqueImageJson>(
       `${this.baseUrl}/${stringTileCoordinates}.json`,
+      init,
     )
       .then((data) => {
         const images = parseImageData(data, this._imageMetas);
@@ -366,6 +377,9 @@ class ObliqueDataSet {
     if (this._terrainProviderOptions) {
       config.terrainProvider = { ...this._terrainProviderOptions };
     }
+    if (this._headers) {
+      config.headers = this._headers;
+    }
     return config;
   }
 }

package/src/oblique/obliqueImageMeta.ts

@@ -17,6 +17,7 @@ export type ObliqueImageMetaOptions = {
   terrainProvider?: CesiumTerrainProvider;
   name: string;
   format?: string;
+  headers?: Record<string, string>;
 };
 
 class ObliqueImageMeta {
@@ -64,6 +65,8 @@ class ObliqueImageMeta {
 
   format: string;
 
+  headers?: Record<string, string>;
+
   constructor(options: ObliqueImageMetaOptions) {
     this.name = options.name;
     this.principalPoint = options['principal-point'];
@@ -78,6 +81,7 @@ class ObliqueImageMeta {
     this.url = options.url;
     this.terrainProvider = options.terrainProvider;
     this.format = options.format || 'jpg';
+    this.headers = options.headers;
   }
 
   /**

package/src/oblique/obliqueView.ts

@@ -1,4 +1,5 @@
 import { v4 as uuidv4 } from 'uuid';
+import { TrustedServers } from '@vcmap-cesium/engine';
 import type { ImageTile } from 'ol';
 import type { Size } from 'ol/size.js';
 import OLProjection from 'ol/proj/Projection.js';
@@ -8,8 +9,9 @@ import TileImage, {
   type Options as TileImageOptions,
 } from 'ol/source/TileImage.js';
 import Tile from 'ol/layer/Tile.js';
-import { hasSameOrigin } from './helpers.js';
 import type ObliqueImageMeta from './obliqueImageMeta.js';
+import { isSameOrigin } from '../util/urlHelpers.js';
+import { getTileLoadFunction } from '../layer/openlayers/loadFunctionHelpers.js';
 
 let defaultImage = '';
 function getDefaultImage(): string {
@@ -61,6 +63,8 @@ class ObliqueView {
 
   private _layer: Tile<TileImage> | undefined;
 
+  private _headers?: Record<string, string>;
+
   constructor(imageMeta: ObliqueImageMeta, options: ObliqueViewOptions) {
     this.size = imageMeta.size;
     this.url = imageMeta.url;
@@ -69,6 +73,7 @@ class ObliqueView {
     this.minZoom = options.minZoom;
     this.maxZoom = options.maxZoom;
     this.scaleFactor = options.scaleFactor;
+    this._headers = imageMeta.headers;
     const { tileResolution } = imageMeta;
     this.tileResolution = tileResolution.slice(
       0,
@@ -106,9 +111,14 @@ class ObliqueView {
         tileSize: this.tileSize,
       }),
     };
-    if (!hasSameOrigin(this.url)) {
+    if (TrustedServers.contains(this.url)) {
+      tileImageOptions.crossOrigin = 'use-credentials';
+    } else if (!isSameOrigin(this.url)) {
       tileImageOptions.crossOrigin = 'anonymous';
     }
+    if (this._headers) {
+      tileImageOptions.tileLoadFunction = getTileLoadFunction(this._headers);
+    }
 
     this._tileImageSource = new TileImage(tileImageOptions);
 

package/src/oblique/parseImageJson.ts

@@ -47,16 +47,18 @@ export function getVersionFromImageJson(json: {
 }
 
 /**
- * @param  json
- * @param  url
- * @param  projection
- * @param  terrainProvider
+ * @param json
+ * @param url
+ * @param projection
+ * @param terrainProvider
+ * @param headers
  */
 export function parseImageMeta(
   json: ObliqueImageJson,
   url: string,
   projection?: Projection,
   terrainProvider?: CesiumTerrainProvider,
+  headers?: Record<string, string>,
 ): ImageMeta[] {
   let size: Size = [0, 0];
   if (json.generalImageInfo.width && json.generalImageInfo.height) {
@@ -84,6 +86,7 @@ export function parseImageMeta(
     projection: imageProjection,
     url,
     terrainProvider,
+    headers,
   };
 
   if (json.generalImageInfo.cameraParameter) {

package/src/ol/geojson.d.ts

@@ -11,8 +11,7 @@ declare module 'geojson' {
     G extends Geometry | null = Geometry,
     P = GeoJsonProperties,
   > {
-    _id?: string | number;
-    id?: string | number;
+    _id?: string;
     radius?: G extends Point ? number : never;
     vcsMeta?: VcsMeta;
     state?: FeatureStoreLayerState;

package/src/ol/geom/circle.ts

@@ -26,7 +26,7 @@ Circle.prototype.setCoordinates = function setCoordinates(
   coordinates: [Coordinate, Coordinate],
   optLayout?: GeometryLayout,
 ): void {
-  check(coordinates, [[Number]]);
+  check(coordinates as [Coordinate, Coordinate], [[Number]]);
   check(coordinates.length, 2);
 
   const layout = optLayout || this.getLayout();