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

package/src/layer/{pointCloudLayer.js → pointCloudLayer.ts}

@@ -1,26 +1,25 @@
 import { checkMaybe } from '@vcsuite/check';
-import CesiumTilesetLayer from './cesiumTilesetLayer.js';
-import DeclarativeStyleItem from '../style/declarativeStyleItem.js';
-import VectorStyleItem from '../style/vectorStyleItem.js';
+// eslint-disable-next-line import/no-named-default
+import type { default as OLStyle, StyleFunction } from 'ol/style/Style.js';
+import CesiumTilesetLayer, {
+  CesiumTilesetOptions,
+} from './cesiumTilesetLayer.js';
+import DeclarativeStyleItem, {
+  DeclarativeStyleItemOptions,
+} from '../style/declarativeStyleItem.js';
+import VectorStyleItem, {
+  VectorStyleItemOptions,
+} from '../style/vectorStyleItem.js';
 import CesiumMap from '../map/cesiumMap.js';
 import CesiumTilesetCesiumImpl from './cesium/cesiumTilesetCesiumImpl.js';
 import { layerClassRegistry } from '../classRegistry.js';
+import StyleItem from '../style/styleItem.js';
+import VcsMap from '../map/vcsMap.js';
 
-/**
- * @typedef {CesiumTilesetOptions} PointCloudOptions
- * @property {number|string|undefined} pointSize - Pointsize of the pointcloud in pixel default is 1
- * @api
- */
-
-/**
- * @typedef {CesiumTilesetImplementationOptions} PointCloudImplementationOptions
- * @property {string|number|undefined} pointSize
- * @api
- */
+export type PointCloudOptions = CesiumTilesetOptions & {
+  pointSize?: number | string;
+};
 
-/**
- * @type {DeclarativeStyleItem}
- */
 export const defaultPointCloudStyle = new DeclarativeStyleItem({});
 
 /**
@@ -30,87 +29,67 @@ export const defaultPointCloudStyle = new DeclarativeStyleItem({});
  *  <li>url: string: url to the p3dm dataset
  *  <li>pointSize: number: size of the points to display
  * </ul>
- *
- * @class
- * @extends {CesiumTilesetLayer}
- * @api stable
  */
 class PointCloudLayer extends CesiumTilesetLayer {
-  static get className() {
+  static get className(): string {
     return 'PointCloudLayer';
   }
 
-  /**
-   * @returns {PointCloudOptions}
-   */
-  static getDefaultOptions() {
+  static getDefaultOptions(): PointCloudOptions {
     return {
       ...CesiumTilesetLayer.getDefaultOptions(),
-      pointSize: null,
+      pointSize: undefined,
     };
   }
 
   /**
-   * @param {PointCloudOptions} options
+   * The default point size to fall back on, if no point size is given. Uses Cesium default of 1 if null.
    */
-  constructor(options) {
+  defaultPointSize: number | string | undefined;
+
+  private _pointSize: number | string | undefined;
+
+  protected _supportedMaps = [CesiumMap.className];
+
+  constructor(options: PointCloudOptions) {
     super(options);
 
     const defaultOptions = PointCloudLayer.getDefaultOptions();
-    /**
-     * The default point size to fall back on, if no point size is given. Uses Cesium default of 1 if null.
-     * @api
-     * @type {number|string|null}
-     */
+
     this.defaultPointSize =
       options.pointSize != null ? options.pointSize : defaultOptions.pointSize;
-    /** @type {number|string|null} */
     this._pointSize = this.defaultPointSize;
-
-    this._supportedMaps = [CesiumMap.className];
   }
 
-  /**
-   * @inheritDoc
-   * @param {(DeclarativeStyleItemOptions|VectorStyleItemOptions|import("@vcmap/core").StyleItem)=} styleOptions
-   * @param {(VectorStyleItem|DeclarativeStyleItem)=} defaultStyle
-   * @returns {import("@vcmap/core").StyleItem}
-   */
-  getStyleOrDefaultStyle(styleOptions, defaultStyle) {
+  getStyleOrDefaultStyle(
+    styleOptions?:
+      | DeclarativeStyleItemOptions
+      | VectorStyleItemOptions
+      | StyleItem,
+    defaultStyle?: VectorStyleItem | DeclarativeStyleItem,
+  ): StyleItem {
     return super.getStyleOrDefaultStyle(
       styleOptions,
       defaultStyle || defaultPointCloudStyle,
     );
   }
 
-  /**
-   * @type {number|string|null}
-   * @api
-   */
-  get pointSize() {
+  get pointSize(): number | string | undefined {
     return this._pointSize;
   }
 
-  /**
-   * @param {string|number|undefined} size
-   */
-  set pointSize(size) {
+  set pointSize(size: string | number | undefined) {
     checkMaybe(size, [Number, String]);
     this._pointSize = size;
-    /** @type {DeclarativeStyleItem} */ (this.style).pointSize =
-      size?.toString();
+    (this.style as DeclarativeStyleItem).pointSize = size?.toString();
   }
 
-  async initialize() {
+  async initialize(): Promise<void> {
     await super.initialize();
     this.pointSize = this._pointSize;
   }
 
-  /**
-   * @param {import("@vcmap/core").VcsMap} map
-   * @returns {Array<CesiumTilesetCesiumImpl>}
-   */
-  createImplementationsForMap(map) {
+  createImplementationsForMap(map: VcsMap): CesiumTilesetCesiumImpl[] {
     if (map instanceof CesiumMap) {
       return [
         new CesiumTilesetCesiumImpl(map, this.getImplementationOptions()),
@@ -122,20 +101,16 @@ class PointCloudLayer extends CesiumTilesetLayer {
 
   /**
    * Clears the style of this layer resets the point size to the defaultPointSize
-   * @api stable
    */
-  clearStyle() {
+  clearStyle(): void {
     super.clearStyle();
     this.pointSize = this.defaultPointSize;
   }
 
   /**
    * Sets a new declarative style. Cannot set a VectorLayer style on PointCloudLayer layers.
-   * @param {import("ol/style/Style").default|import("ol/style/Style").StyleFunction|import("@vcmap/core").StyleItem} style
-   * @param {boolean=} silent
-   * @api
    */
-  setStyle(style, silent) {
+  setStyle(style: OLStyle | StyleFunction | StyleItem, silent?: boolean): void {
     if (style instanceof VectorStyleItem) {
       this.getLogger().warning(
         'trying to apply vector style to point cloud layer.',
@@ -145,12 +120,8 @@ class PointCloudLayer extends CesiumTilesetLayer {
     }
   }
 
-  /**
-   * @inheritDoc
-   * @returns {PointCloudOptions}
-   */
-  toJSON() {
-    const config = /** @type {PointCloudOptions} */ (super.toJSON());
+  toJSON(): PointCloudOptions {
+    const config: PointCloudOptions = super.toJSON();
     const defaultOptions = PointCloudLayer.getDefaultOptions();
 
     if (this.defaultPointSize !== defaultOptions.pointSize) {

package/src/layer/{rasterLayer.js → rasterLayer.ts}

@@ -17,57 +17,72 @@ import {
   parseEnumValue,
 } from '@vcsuite/parsers';
 import { wgs84Projection } from '../util/projection.js';
-import Layer from './layer.js';
+import Layer, {
+  LayerImplementationOptions,
+  LayerOptions,
+  SplitLayer,
+} from './layer.js';
 import VcsEvent from '../vcsEvent.js';
 import Extent from '../util/extent.js';
 import { layerClassRegistry } from '../classRegistry.js';
+import LayerImplementation from './layerImplementation.js';
+import VcsMap from '../map/vcsMap.js';
 
-/**
- * @typedef {LayerOptions} RasterLayerOptions
- * @property {number|undefined} [minLevel=0] -  minLevel to show (if not specified, calculated from extent)
- * @property {number} [maxLevel=18] -  maxLevel to show
- * @property {string} [tilingSchema='geographic'] -  either "geographic" or "mercator"
- * @property {number} [opacity=1.0] - opacity between 0 and 1
- * @property {string|undefined} splitDirection - either 'left' or 'right', none if omitted
- * @api
- */
+export type RasterLayerOptions = LayerOptions & {
+  /**
+   * minLevel to show (if not specified, calculated from extent)
+   * @default 0
+   */
+  minLevel?: number;
+  /**
+   * maxLevel to show
+   * @default 18
+   */
+  maxLevel?: number;
+  tilingSchema?: TilingScheme;
+  /**
+   * opacity between 0 and 1
+   * @default 1
+   */
+  opacity?: number;
+  /**
+   * either 'left' or 'right', none if omitted
+   */
+  splitDirection?: string;
+};
 
-/**
- * @typedef {LayerImplementationOptions} RasterLayerImplementationOptions
- * @property {number} minLevel
- * @property {number} maxLevel
- * @property {string} tilingSchema
- * @property {number} opacity
- * @property {Extent|undefined} extent
- * @property {import("@vcmap-cesium/engine").SplitDirection} splitDirection
- */
+export type RasterLayerImplementationOptions = LayerImplementationOptions & {
+  minLevel: number;
+  maxLevel: number;
+  tilingSchema: TilingScheme;
+  opacity: number;
+  extent?: Extent;
+  splitDirection: SplitDirection;
+};
 
-/**
- * @typedef {import("@vcmap/core").LayerImplementation<import("@vcmap/core").VcsMap>} RasterLayerImplementation
- * @property {function(number):void} updateOpacity
- * @property {function(import("@vcmap-cesium/engine").SplitDirection):void} updateSplitDirection
- * @api
- */
+export interface RasterLayerImplementation {
+  updateOpacity(opacity: number): void;
+  updateSplitDirection(splitDirection: SplitDirection): void;
+}
 
-/**
- * Enumeration of tiling schemes.
- * @enum {string}
- * @api
- * @property {string} GEOGRAPHIC
- * @property {string} MERCATOR
- */
-export const TilingScheme = {
-  GEOGRAPHIC: 'geographic',
-  MERCATOR: 'mercator',
+export enum TilingScheme {
+  GEOGRAPHIC = 'geographic',
+  MERCATOR = 'mercator',
+}
+
+export type TilingSchemeOptions = {
+  numberOfLevelZeroTilesX?: number;
+  numberOfLevelZeroTilesY?: number;
 };
 
 /**
  * Gets the tiling scheme associated with this layerConfig
- * @param {Object} layerOptions
- * @returns {import("@vcmap-cesium/engine").WebMercatorTilingScheme|import("@vcmap-cesium/engine").GeographicTilingScheme}
+ * @param  layerOptions
  */
-export function getTilingScheme(layerOptions) {
-  const tilingSchemeOptions = {};
+export function getTilingScheme(
+  layerOptions: RasterLayerOptions & TilingSchemeOptions,
+): WebMercatorTilingScheme | GeographicTilingScheme {
+  const tilingSchemeOptions: TilingSchemeOptions = {};
   if (
     layerOptions.numberOfLevelZeroTilesX &&
     layerOptions.numberOfLevelZeroTilesX > 1
@@ -88,19 +103,12 @@ export function getTilingScheme(layerOptions) {
   return new GeographicTilingScheme(tilingSchemeOptions);
 }
 
-/**
- * @param {Extent} extent
- * @param {import("@vcmap-cesium/engine").GeographicTilingScheme|import("@vcmap-cesium/engine").WebMercatorTilingScheme} tilingScheme
- * @param {number} maxLevel
- * @param {number} [minLevel=0]
- * @returns {number}
- */
 export function calculateMinLevel(
-  extent,
-  tilingScheme,
-  maxLevel,
+  extent: Extent,
+  tilingScheme: GeographicTilingScheme | WebMercatorTilingScheme,
+  maxLevel: number,
   minLevel = 0,
-) {
+): number {
   if (!extent.isValid()) {
     return minLevel;
   }
@@ -120,9 +128,9 @@ export function calculateMinLevel(
   const extentCoords = olCoords.map((coord) =>
     Cartographic.fromDegrees(coord[0], coord[1]),
   );
-  let usedMinLevel = minLevel;
+  let usedMinLevel: number = minLevel;
   while (usedMinLevel < maxLevel) {
-    // eslint-disable-next-line no-loop-func
+    // eslint-disable-next-line @typescript-eslint/no-loop-func
     const tileCoords = extentCoords.map((position) =>
       tilingScheme.positionToTileXY(position, usedMinLevel),
     );
@@ -141,20 +149,18 @@ export function calculateMinLevel(
 /**
  * This abstract class allows for automatic loading scheme determination
  * for raster layers
- * @class
- * @extends {Layer}
- * @implements {SplitLayer}
- * @abstract
  */
-class RasterLayer extends Layer {
-  static get className() {
+class RasterLayer<
+    I extends LayerImplementation<VcsMap> & RasterLayerImplementation,
+  >
+  extends Layer<I>
+  implements SplitLayer
+{
+  static get className(): string {
     return 'RasterLayer';
   }
 
-  /**
-   * @returns {RasterLayerOptions}
-   */
-  static getDefaultOptions() {
+  static getDefaultOptions(): RasterLayerOptions {
     return {
       ...Layer.getDefaultOptions(),
       minLevel: 0,
@@ -165,88 +171,78 @@ class RasterLayer extends Layer {
     };
   }
 
+  extent: Extent;
+
   /**
-   * @param {RasterLayerOptions} options
+   * The {@link TilingScheme} of this layer
    */
-  constructor(options) {
+  tilingSchema: TilingScheme;
+
+  maxLevel: number;
+
+  private _minLevel: number;
+
+  minLevel: number;
+
+  private _opacity: number;
+
+  private _splitDirection: SplitDirection = SplitDirection.NONE;
+
+  /**
+   * raised if the split direction changes, is passed the split direction as its only argument
+   */
+  splitDirectionChanged: VcsEvent<SplitDirection> = new VcsEvent();
+
+  /**
+   * @param  options
+   */
+  constructor(options: RasterLayerOptions) {
     options.url = options.url || '';
     super(options);
     const defaultOptions = RasterLayer.getDefaultOptions();
-    this.extent = this.extent || new Extent();
-    /**
-     * The {@link RasterLayer.TilingScheme} of this layer
-     * @type {string}
-     * @api
-     */
+    this.extent = options.extent ? new Extent(options.extent) : new Extent();
     this.tilingSchema = parseEnumValue(
       options.tilingSchema,
       TilingScheme,
-      defaultOptions.tilingSchema,
+      defaultOptions.tilingSchema as TilingScheme,
     );
-    /** @type {number} */
     this.maxLevel = parseInteger(options.maxLevel, defaultOptions.maxLevel);
-    /**
-     * @type {number}
-     * @private
-     */
     this._minLevel = parseInteger(options.minLevel, defaultOptions.minLevel);
 
     const cesiumTilingScheme = getTilingScheme(options);
-    /** @type {number} */
     this.minLevel = calculateMinLevel(
       this.extent,
       cesiumTilingScheme,
       this.maxLevel,
       this._minLevel,
     );
-
-    /**
-     * @type {number}
-     * @private
-     */
     this._opacity = parseNumberRange(
       options.opacity,
-      defaultOptions.opacity,
+      defaultOptions.opacity as number,
       0.0,
       1.0,
     );
 
-    /** @type {import("@vcmap-cesium/engine").SplitDirection} */
-    this._splitDirection = SplitDirection.NONE;
-
     if (options.splitDirection) {
       this._splitDirection =
         options.splitDirection === 'left'
           ? SplitDirection.LEFT
           : SplitDirection.RIGHT;
     }
-
-    /**
-     * raised if the split direction changes, is passed the split direction as its only argument
-     * @type {VcsEvent<import("@vcmap-cesium/engine").SplitDirection>}
-     * @api
-     */
-    this.splitDirectionChanged = new VcsEvent();
   }
 
   /**
    * The split directions of this layer
-   * @api
-   * @type {import("@vcmap-cesium/engine").SplitDirection}
    */
-  get splitDirection() {
+  get splitDirection(): SplitDirection {
     return this._splitDirection;
   }
 
-  /**
-   * @param {import("@vcmap-cesium/engine").SplitDirection} direction
-   */
-  set splitDirection(direction) {
+  set splitDirection(direction: SplitDirection) {
     if (direction !== this._splitDirection) {
       this._splitDirection = direction;
       this.getImplementations().forEach((impl) => {
-        /** @type {RasterLayerImplementation} */
-        (impl).updateSplitDirection(direction);
+        impl.updateSplitDirection(direction);
       });
       this.splitDirectionChanged.raiseEvent(this._splitDirection);
     }
@@ -254,55 +250,42 @@ class RasterLayer extends Layer {
 
   /**
    * The opacity between 0 (fully transparent) and 1 (fully opaque)
-   * @api
-   * @type {number}
    */
-  get opacity() {
+  get opacity(): number {
     return this._opacity;
   }
 
-  /**
-   * @param {number} opacity
-   */
-  set opacity(opacity) {
+  set opacity(opacity: number) {
     const parsedValue = parseNumberRange(opacity, this._opacity, 0, 1);
     if (this._opacity !== parsedValue) {
       this._opacity = parsedValue;
       this.getImplementations().forEach((impl) => {
-        /** @type {RasterLayerImplementation} */
-        (impl).updateOpacity(parsedValue);
+        impl.updateOpacity(parsedValue);
       });
     }
   }
 
-  /**
-   * @returns {RasterLayerImplementationOptions}
-   */
-  getImplementationOptions() {
-    const options = /** @type {RasterLayerImplementationOptions} */ ({
+  getImplementationOptions(): RasterLayerImplementationOptions {
+    const options: RasterLayerImplementationOptions = {
       ...super.getImplementationOptions(),
       minLevel: this.minLevel,
       maxLevel: this.maxLevel,
       tilingSchema: this.tilingSchema,
       opacity: this.opacity,
       splitDirection: this._splitDirection,
-    });
+    };
 
-    if (this.extent.isValid()) {
+    if (this.extent?.isValid()) {
       options.extent = this.extent;
     }
     return options;
   }
 
-  /**
-   * @inheritDoc
-   * @returns {RasterLayerOptions}
-   */
-  toJSON() {
-    const config = /** @type {RasterLayerOptions} */ (super.toJSON());
+  toJSON(): RasterLayerOptions {
+    const config: RasterLayerOptions = super.toJSON();
     const defaultOptions = RasterLayer.getDefaultOptions();
 
-    if (this.extent.equals(new Extent())) {
+    if (this.extent?.equals(new Extent())) {
       delete config.extent;
     }
 
@@ -330,10 +313,7 @@ class RasterLayer extends Layer {
     return config;
   }
 
-  /**
-   * @inheritDoc
-   */
-  destroy() {
+  destroy(): void {
     this.splitDirectionChanged.destroy();
     super.destroy();
   }

package/src/layer/{singleImageLayer.js → singleImageLayer.ts}

@@ -1,5 +1,8 @@
 import { check } from '@vcsuite/check';
-import RasterLayer from './rasterLayer.js';
+import RasterLayer, {
+  RasterLayerImplementationOptions,
+  RasterLayerOptions,
+} from './rasterLayer.js';
 import SingleImageCesiumImpl from './cesium/singleImageCesiumImpl.js';
 import SingleImageOpenlayersImpl from './openlayers/singleImageOpenlayersImpl.js';
 import CesiumMap from '../map/cesiumMap.js';
@@ -7,46 +10,39 @@ import OpenlayersMap from '../map/openlayersMap.js';
 import Extent from '../util/extent.js';
 import { layerClassRegistry } from '../classRegistry.js';
 import { wgs84Projection } from '../util/projection.js';
+import VcsMap from '../map/vcsMap.js';
 
-/**
- * @typedef {RasterLayerOptions} SingleImageOptions
- * @property {string|undefined} credit -  credit
- * @api
- */
+export type SingleImageOptions = RasterLayerOptions & {
+  credit?: string;
+};
 
-/**
- * @typedef {RasterLayerImplementationOptions} SingleImageImplementationOptions
- * @property {string|undefined} credit
- */
+export type SingleImageImplementationOptions =
+  RasterLayerImplementationOptions & {
+    credit?: string;
+  };
 
 /**
  * Image layer for Cesium and OpenlayersMap
- * @class
- * @extends {RasterLayer}
- * @api stable
  */
-class SingleImageLayer extends RasterLayer {
-  static get className() {
+class SingleImageLayer extends RasterLayer<
+  SingleImageCesiumImpl | SingleImageOpenlayersImpl
+> {
+  static get className(): string {
     return 'SingleImageLayer';
   }
 
-  /**
-   * @returns {SingleImageOptions}
-   */
-  static getDefaultOptions() {
+  static getDefaultOptions(): SingleImageOptions {
     return {
       ...RasterLayer.getDefaultOptions(),
       credit: undefined,
     };
   }
 
-  /**
-   * @param {SingleImageOptions} options
-   */
-  constructor(options) {
+  credit: string | undefined;
+
+  constructor(options: SingleImageOptions) {
     super(options);
     const defaultOptions = SingleImageLayer.getDefaultOptions();
-    /** @type {string} */
     this.credit = options.credit || defaultOptions.credit;
 
     if (!this.extent.isValid()) {
@@ -62,21 +58,16 @@ class SingleImageLayer extends RasterLayer {
     this._supportedMaps = [CesiumMap.className, OpenlayersMap.className];
   }
 
-  /**
-   * @returns {SingleImageImplementationOptions}
-   */
-  getImplementationOptions() {
+  getImplementationOptions(): SingleImageImplementationOptions {
     return {
       ...super.getImplementationOptions(),
       credit: this.credit,
     };
   }
 
-  /**
-   * @param {import("@vcmap/core").VcsMap} map
-   * @returns {Array<SingleImageOpenlayersImpl|SingleImageCesiumImpl>}
-   */
-  createImplementationsForMap(map) {
+  createImplementationsForMap(
+    map: VcsMap,
+  ): (SingleImageOpenlayersImpl | SingleImageCesiumImpl)[] {
     if (map instanceof CesiumMap) {
       return [new SingleImageCesiumImpl(map, this.getImplementationOptions())];
     } else if (map instanceof OpenlayersMap) {
@@ -89,25 +80,21 @@ class SingleImageLayer extends RasterLayer {
 
   /**
    * sets the image extent
-   * @param {Extent} extent
-   * @api
+   * @param  extent
    */
-  setExtent(extent) {
+  setExtent(extent: Extent): void {
     check(extent, Extent);
     if (!extent.isValid()) {
       throw new Error('Cannot set invalid extent');
     }
 
     this.extent = extent;
-    this.forceRedraw();
+    // eslint-disable-next-line no-void
+    void this.forceRedraw();
   }
 
-  /**
-   * @inheritDoc
-   * @returns {SingleImageOptions}
-   */
-  toJSON() {
-    const config = /** @type {SingleImageOptions} */ (super.toJSON());
+  toJSON(): SingleImageOptions {
+    const config: SingleImageOptions = super.toJSON();
     delete config.tilingSchema;
 
     if (this.credit) {