@vcmap/core 5.0.0-rc.32 → 5.0.0-rc.34

package/src/layer/cesium/{openStreetMapCesiumImpl.js → openStreetMapCesiumImpl.ts}

@@ -6,19 +6,13 @@ import RasterLayerCesiumImpl from './rasterLayerCesiumImpl.js';
 
 /**
  * represents a specific OpenStreetMapLayer layer for cesium.
- * @class
- * @extends {RasterLayerCesiumImpl}
  */
 class OpenStreetMapCesiumImpl extends RasterLayerCesiumImpl {
-  static get className() {
+  static get className(): string {
     return 'OpenStreetMapCesiumImpl';
   }
 
-  /**
-   * @inheritDoc
-   * @returns {import("@vcmap-cesium/engine").ImageryLayer}
-   */
-  getCesiumLayer() {
+  getCesiumLayer(): CesiumImageryLayer {
     return new CesiumImageryLayer(
       new OpenStreetMapImageryProvider({ maximumLevel: this.maxLevel }),
       {

package/src/layer/cesium/{rasterLayerCesiumImpl.js → rasterLayerCesiumImpl.ts}

@@ -1,44 +1,47 @@
+import type { ImageryLayer, SplitDirection } from '@vcmap-cesium/engine';
 import { vcsLayerName } from '../layerSymbols.js';
 import LayerImplementation from '../layerImplementation.js';
+import type CesiumMap from '../../map/cesiumMap.js';
+import type {
+  RasterLayerImplementation,
+  RasterLayerImplementationOptions,
+  TilingScheme,
+} from '../rasterLayer.js';
+import type Extent from '../../util/extent.js';
 
-/**
- * RasterLayer implementation for {@link Openlayers}
- * @class
- * @extends {LayerImplementation<import("@vcmap/core").CesiumMap>}}
- * @implements {RasterLayerImplementation}
- */
-class RasterLayerCesiumImpl extends LayerImplementation {
-  static get className() {
+class RasterLayerCesiumImpl
+  extends LayerImplementation<CesiumMap>
+  implements RasterLayerImplementation
+{
+  static get className(): string {
     return 'RasterLayerCesiumImpl';
   }
 
-  /**
-   * @param {import("@vcmap/core").CesiumMap} map
-   * @param {RasterLayerImplementationOptions} options
-   */
-  constructor(map, options) {
+  cesiumLayer: ImageryLayer | null = null;
+
+  splitDirection: SplitDirection;
+
+  minLevel: number;
+
+  maxLevel: number;
+
+  extent: Extent | undefined;
+
+  opacity: number;
+
+  tilingSchema: TilingScheme;
+
+  constructor(map: CesiumMap, options: RasterLayerImplementationOptions) {
     super(map, options);
-    /** @type {import("@vcmap-cesium/engine").ImageryLayer|null} */
-    this.cesiumLayer = null;
-    /** @type {import("@vcmap-cesium/engine").SplitDirection} */
     this.splitDirection = options.splitDirection;
-    /** @type {number} */
     this.minLevel = options.minLevel;
-    /** @type {number} */
     this.maxLevel = options.maxLevel;
-    /** @type {string} */
-    this.tilingSchema = options.tilingSchema;
-    /** @type {import("@vcmap/core").Extent} */
     this.extent = options.extent;
-    /** @type {number} */
     this.opacity = options.opacity;
+    this.tilingSchema = options.tilingSchema;
   }
 
-  /**
-   * @inheritDoc
-   * @returns {Promise<void>}
-   */
-  initialize() {
+  initialize(): Promise<void> {
     if (!this.initialized) {
       this.cesiumLayer = this.getCesiumLayer();
       this.cesiumLayer[vcsLayerName] = this.name;
@@ -48,60 +51,40 @@ class RasterLayerCesiumImpl extends LayerImplementation {
     return super.initialize();
   }
 
-  /**
-   * @param {import("@vcmap-cesium/engine").SplitDirection} splitDirection
-   */
-  updateSplitDirection(splitDirection) {
+  updateSplitDirection(splitDirection: SplitDirection): void {
     this.splitDirection = splitDirection;
-    if (this.initialized) {
+    if (this.initialized && this.cesiumLayer) {
       this.cesiumLayer.splitDirection = splitDirection;
     }
   }
 
-  // eslint-disable-next-line jsdoc/require-returns-check
-  /**
-   * @returns {import("@vcmap-cesium/engine").ImageryLayer}
-   */
   // eslint-disable-next-line class-methods-use-this
-  getCesiumLayer() {
+  getCesiumLayer(): ImageryLayer {
     throw new Error('implementation error');
   }
 
-  /**
-   * @inheritDoc
-   * @returns {Promise<void>}
-   */
-  async activate() {
+  async activate(): Promise<void> {
     await super.activate();
-    if (this.active) {
+    if (this.active && this.cesiumLayer) {
       this.cesiumLayer.show = true;
     }
   }
 
-  /**
-   * @inheritDoc
-   */
-  deactivate() {
+  deactivate(): void {
     super.deactivate();
     if (this.cesiumLayer) {
       this.cesiumLayer.show = false;
     }
   }
 
-  /**
-   * @param {number} opacity
-   */
-  updateOpacity(opacity) {
+  updateOpacity(opacity: number): void {
     this.opacity = opacity;
     if (this.initialized && this.cesiumLayer) {
       this.cesiumLayer.alpha = opacity;
     }
   }
 
-  /**
-   * @inheritDoc
-   */
-  destroy() {
+  destroy(): void {
     if (this.cesiumLayer) {
       this.map.removeImageryLayer(this.cesiumLayer);
     }

package/src/layer/cesium/{singleImageCesiumImpl.js → singleImageCesiumImpl.ts}

@@ -5,37 +5,31 @@ import {
 } from '@vcmap-cesium/engine';
 import RasterLayerCesiumImpl from './rasterLayerCesiumImpl.js';
 import { wgs84Projection } from '../../util/projection.js';
+import type { SingleImageImplementationOptions } from '../singleImageLayer.js';
+import type CesiumMap from '../../map/cesiumMap.js';
 
 /**
  * represents a specific Cesium SingleTileImagery Layer class.
- * @class
- * @extends {RasterLayerCesiumImpl}
  */
 class SingleImageCesiumImpl extends RasterLayerCesiumImpl {
-  static get className() {
+  static get className(): string {
     return 'SingleImageCesiumImpl';
   }
 
-  /**
-   * @param {import("@vcmap/core").CesiumMap} map
-   * @param {SingleImageImplementationOptions} options
-   */
-  constructor(map, options) {
+  credit: string | undefined;
+
+  constructor(map: CesiumMap, options: SingleImageImplementationOptions) {
     super(map, options);
-    /** @type {string} */
     this.credit = options.credit;
   }
 
-  /**
-   * @returns {import("@vcmap-cesium/engine").ImageryLayer}
-   */
-  getCesiumLayer() {
-    const options = {
-      url: this.url,
+  getCesiumLayer(): ImageryLayer {
+    const options: SingleTileImageryProvider.ConstructorOptions = {
+      url: this.url as string,
       credit: this.credit,
     };
 
-    const extent = this.extent.getCoordinatesInProjection(wgs84Projection);
+    const extent = this.extent?.getCoordinatesInProjection(wgs84Projection);
     if (extent) {
       options.rectangle = Rectangle.fromDegrees(
         extent[0],

package/src/layer/cesium/terrainCesiumImpl.ts

@@ -0,0 +1,63 @@
+import type { CesiumTerrainProvider } from '@vcmap-cesium/engine';
+import LayerImplementation from '../layerImplementation.js';
+import { vcsLayerName } from '../layerSymbols.js';
+import { getTerrainProviderForUrl } from '../terrainHelpers.js';
+import CesiumMap from '../../map/cesiumMap.js';
+import type { TerrainImplementationOptions } from '../terrainLayer.js';
+
+/**
+ * TerrainLayer implementation for {@link CesiumMap}
+ */
+class TerrainCesiumImpl extends LayerImplementation<CesiumMap> {
+  static get className(): string {
+    return 'TerrainCesiumImpl';
+  }
+
+  requestVertexNormals: boolean;
+
+  requestWaterMask: boolean;
+
+  terrainProvider: CesiumTerrainProvider | undefined = undefined;
+
+  constructor(map: CesiumMap, options: TerrainImplementationOptions) {
+    super(map, options);
+
+    this.requestVertexNormals = options.requestVertexNormals;
+    this.requestWaterMask = options.requestWaterMask;
+  }
+
+  async initialize(): Promise<void> {
+    if (!this.initialized) {
+      this.terrainProvider = await getTerrainProviderForUrl(
+        this.url as string,
+        {
+          requestVertexNormals: this.requestVertexNormals,
+          requestWaterMask: this.requestWaterMask,
+        },
+      );
+      this.terrainProvider[vcsLayerName] = this.name;
+    }
+    return super.initialize();
+  }
+
+  async activate(): Promise<void> {
+    await super.activate();
+    if (this.active && this.terrainProvider) {
+      this.map.setTerrainProvider(this.terrainProvider);
+    }
+  }
+
+  deactivate(): void {
+    super.deactivate();
+    if (this.terrainProvider) {
+      this.map.unsetTerrainProvider(this.terrainProvider);
+    }
+  }
+
+  destroy(): void {
+    this.terrainProvider = undefined;
+    super.destroy();
+  }
+}
+
+export default TerrainCesiumImpl;

package/src/layer/cesium/{tmsCesiumImpl.js → tmsCesiumImpl.ts}

@@ -7,36 +7,32 @@ import {
 import RasterLayerCesiumImpl from './rasterLayerCesiumImpl.js';
 import { wgs84Projection } from '../../util/projection.js';
 import { TilingScheme } from '../rasterLayer.js';
+import type CesiumMap from '../../map/cesiumMap.js';
+import type { TMSImplementationOptions } from '../tmsLayer.js';
 
 /**
  * TmsLayer implementation for {@link CesiumMap}.
- * @class
- * @extends {RasterLayerCesiumImpl}
  */
 class TmsCesiumImpl extends RasterLayerCesiumImpl {
-  static get className() {
+  static get className(): string {
     return 'TmsCesiumImpl';
   }
 
-  /**
-   * @param {import("@vcmap/core").CesiumMap} map
-   * @param {TMSImplementationOptions} options
-   */
-  constructor(map, options) {
+  format: string;
+
+  constructor(map: CesiumMap, options: TMSImplementationOptions) {
     super(map, options);
-    /** @type {string} */
     this.format = options.format;
   }
 
-  /**
-   * @returns {import("@vcmap-cesium/engine").ImageryLayer}
-   */
-  getCesiumLayer() {
-    const options = {
+  getCesiumLayer(): CesiumImageryLayer {
+    const options: TileMapServiceImageryProvider.ConstructorOptions = {
       url: this.url,
       fileExtension: this.format,
       maximumLevel: this.maxLevel,
       minimumLevel: this.minLevel,
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-ignore
       show: false,
     };