@vcmap/core 5.0.0-rc.3 → 5.0.0-rc.30

package/src/{vcs/vcm/layer/openStreetMap.js → layer/openStreetMapLayer.js}

@@ -1,13 +1,13 @@
-import { ImagerySplitDirection } from '@vcmap/cesium';
+import { SplitDirection } from '@vcmap-cesium/engine';
 
 import { parseNumberRange, parseInteger } from '@vcsuite/parsers';
 import Layer from './layer.js';
-import Openlayers from '../maps/openlayers.js';
-import CesiumMap from '../maps/cesium.js';
-import OpenStreetMapOpenlayers from './openlayers/openStreetMapOpenlayers.js';
-import OpenStreetMapCesium from './cesium/openStreetMapCesium.js';
-import VcsEvent from '../event/vcsEvent.js';
-import { VcsClassRegistry } from '../classRegistry.js';
+import OpenlayersMap from '../map/openlayersMap.js';
+import CesiumMap from '../map/cesiumMap.js';
+import OpenStreetMapOpenlayersImpl from './openlayers/openStreetMapOpenlayersImpl.js';
+import OpenStreetMapCesiumImpl from './cesium/openStreetMapCesiumImpl.js';
+import VcsEvent from '../vcsEvent.js';
+import { layerClassRegistry } from '../classRegistry.js';
 
 /**
  * @typedef {LayerOptions} OpenStreetMapOptions
@@ -18,15 +18,16 @@ import { VcsClassRegistry } from '../classRegistry.js';
  */
 
 /**
- * OpenStreetMap Layer
+ * OpenStreetMapLayer Layer
  * @class
- * @export
  * @extends {Layer}
  * @api stable
  * @implements {SplitLayer}
  */
-class OpenStreetMap extends Layer {
-  static get className() { return 'vcs.vcm.layer.OpenStreetMap'; }
+class OpenStreetMapLayer extends Layer {
+  static get className() {
+    return 'OpenStreetMapLayer';
+  }
 
   /**
    * @returns {OpenStreetMapOptions}
@@ -45,33 +46,36 @@ class OpenStreetMap extends Layer {
    */
   constructor(options) {
     super(options);
-    const defaultOptions = OpenStreetMap.getDefaultOptions();
+    const defaultOptions = OpenStreetMapLayer.getDefaultOptions();
     /**
-     * @type {import("@vcmap/cesium").ImagerySplitDirection}
+     * @type {import("@vcmap-cesium/engine").SplitDirection}
      * @private
      */
-    this._splitDirection = ImagerySplitDirection.NONE;
+    this._splitDirection = SplitDirection.NONE;
 
     if (options.splitDirection) {
-      this._splitDirection = options.splitDirection === 'left' ?
-        ImagerySplitDirection.LEFT :
-        ImagerySplitDirection.RIGHT;
+      this._splitDirection =
+        options.splitDirection === 'left'
+          ? SplitDirection.LEFT
+          : SplitDirection.RIGHT;
     }
 
-    this._supportedMaps = [
-      CesiumMap.className,
-      Openlayers.className,
-    ];
+    this._supportedMaps = [CesiumMap.className, OpenlayersMap.className];
 
     /**
      * @type {number}
      * @private
      */
-    this._opacity = parseNumberRange(options.opacity, defaultOptions.opacity, 0.0, 1.0);
+    this._opacity = parseNumberRange(
+      options.opacity,
+      defaultOptions.opacity,
+      0.0,
+      1.0,
+    );
 
     /**
      * raised if the split direction changes, is passed the split direction as its only argument
-     * @type {VcsEvent<import("@vcmap/cesium").ImagerySplitDirection>}
+     * @type {VcsEvent<import("@vcmap-cesium/engine").SplitDirection>}
      * @api
      */
     this.splitDirectionChanged = new VcsEvent();
@@ -86,18 +90,20 @@ class OpenStreetMap extends Layer {
 
   /**
    * @api
-   * @type {import("@vcmap/cesium").ImagerySplitDirection}
+   * @type {import("@vcmap-cesium/engine").SplitDirection}
    */
-  get splitDirection() { return this._splitDirection; }
+  get splitDirection() {
+    return this._splitDirection;
+  }
 
   /**
-   * @param {import("@vcmap/cesium").ImagerySplitDirection} direction
+   * @param {import("@vcmap-cesium/engine").SplitDirection} direction
    */
   set splitDirection(direction) {
     if (direction !== this._splitDirection) {
       this._splitDirection = direction;
       this.getImplementations().forEach((impl) => {
-        /** @type {OpenStreetMapCesium|OpenStreetMapOpenlayers} */
+        /** @type {OpenStreetMapCesiumImpl|OpenStreetMapOpenlayersImpl} */
         (impl).updateSplitDirection(this._splitDirection);
       });
       this.splitDirectionChanged.raiseEvent(this._splitDirection);
@@ -109,7 +115,9 @@ class OpenStreetMap extends Layer {
    * @api
    * @type {number}
    */
-  get opacity() { return this._opacity; }
+  get opacity() {
+    return this._opacity;
+  }
 
   /**
    * @param {number} opacity
@@ -119,7 +127,7 @@ class OpenStreetMap extends Layer {
     if (this._opacity !== parsedValue) {
       this._opacity = parsedValue;
       this.getImplementations().forEach((impl) => {
-        /** @type {OpenStreetMapCesium|OpenStreetMapOpenlayers} */
+        /** @type {OpenStreetMapCesiumImpl|OpenStreetMapOpenlayersImpl} */
         (impl).updateOpacity(parsedValue);
       });
     }
@@ -143,15 +151,19 @@ class OpenStreetMap extends Layer {
   /**
    * @inheritDoc
    * @param {import("@vcmap/core").VcsMap} map
-   * @returns {Array<OpenStreetMapOpenlayers|OpenStreetMapCesium>}
+   * @returns {Array<OpenStreetMapOpenlayersImpl|OpenStreetMapCesiumImpl>}
    */
   createImplementationsForMap(map) {
-    if (map instanceof Openlayers) {
-      return [new OpenStreetMapOpenlayers(map, this.getImplementationOptions())];
+    if (map instanceof OpenlayersMap) {
+      return [
+        new OpenStreetMapOpenlayersImpl(map, this.getImplementationOptions()),
+      ];
     }
 
     if (map instanceof CesiumMap) {
-      return [new OpenStreetMapCesium(map, this.getImplementationOptions())];
+      return [
+        new OpenStreetMapCesiumImpl(map, this.getImplementationOptions()),
+      ];
     }
     return [];
   }
@@ -162,12 +174,11 @@ class OpenStreetMap extends Layer {
    */
   toJSON() {
     const config = /** @type {OpenStreetMapOptions} */ (super.toJSON());
-    const defaultOptions = OpenStreetMap.getDefaultOptions();
+    const defaultOptions = OpenStreetMapLayer.getDefaultOptions();
 
-    if (this._splitDirection !== ImagerySplitDirection.NONE) {
-      config.splitDirection = this._splitDirection === ImagerySplitDirection.RIGHT ?
-        'right' :
-        'left';
+    if (this._splitDirection !== SplitDirection.NONE) {
+      config.splitDirection =
+        this._splitDirection === SplitDirection.RIGHT ? 'right' : 'left';
     }
 
     if (this.opacity !== defaultOptions.opacity) {
@@ -178,6 +189,11 @@ class OpenStreetMap extends Layer {
       config.maxLevel = this.maxLevel;
     }
 
+    if (this._splitDirection !== SplitDirection.NONE) {
+      config.splitDirection =
+        this._splitDirection === SplitDirection.RIGHT ? 'right' : 'left';
+    }
+
     return config;
   }
 
@@ -190,5 +206,8 @@ class OpenStreetMap extends Layer {
   }
 }
 
-VcsClassRegistry.registerClass(OpenStreetMap.className, OpenStreetMap);
-export default OpenStreetMap;
+layerClassRegistry.registerClass(
+  OpenStreetMapLayer.className,
+  OpenStreetMapLayer,
+);
+export default OpenStreetMapLayer;

package/src/layer/openlayers/layerOpenlayersImpl.js

@@ -0,0 +1,165 @@
+import { SplitDirection } from '@vcmap-cesium/engine';
+import { unByKey } from 'ol/Observable.js';
+import { vcsLayerName } from '../layerSymbols.js';
+import LayerImplementation from '../layerImplementation.js';
+
+/**
+ * @typedef {LayerImplementationOptions} LayerOpenlayersImplementationOptions
+ * @property {import("@vcmap-cesium/engine").SplitDirection} splitDirection
+ */
+
+/**
+ * Layer implementation for {@link OpenlayersMap}.
+ * @class
+ * @extends {LayerImplementation<import("@vcmap/core").OpenlayersMap>}}
+ */
+class LayerOpenlayersImpl extends LayerImplementation {
+  static get className() {
+    return 'LayerOpenlayersImpl';
+  }
+
+  /**
+   * @param {import("@vcmap/core").OpenlayersMap} map
+   * @param {LayerOpenlayersImplementationOptions} options
+   */
+  constructor(map, options) {
+    super(map, options);
+    /**
+     * @type {import("ol/layer").Layer<import("ol/source/Source").default>|null}
+     */
+    this.olLayer = null;
+    /** @type {import("@vcmap-cesium/engine").SplitDirection} */
+    this.splitDirection = options.splitDirection;
+    /**
+     * @type {Array<import("ol/events").EventsKey>|null}
+     * @private
+     */
+    this._splitDirectionRenderListeners = null;
+  }
+
+  /**
+   * @inheritDoc
+   * @returns {Promise<void>}
+   */
+  async initialize() {
+    if (!this.initialized) {
+      this.olLayer = this.getOLLayer();
+      this.olLayer[vcsLayerName] = this.name;
+      this.map.addOLLayer(this.olLayer);
+    }
+    await super.initialize();
+    this.updateSplitDirection(this.splitDirection);
+  }
+
+  /**
+   * @inheritDoc
+   * @returns {Promise<void>}
+   */
+  async activate() {
+    await super.activate();
+    if (this.active) {
+      this.olLayer.setVisible(true);
+    }
+  }
+
+  /**
+   * @inheritDoc
+   */
+  deactivate() {
+    super.deactivate();
+    if (this.olLayer) {
+      this.olLayer.setVisible(false);
+    }
+  }
+
+  // eslint-disable-next-line jsdoc/require-returns-check
+  /**
+   * returns the ol Layer
+   * @returns {import("ol/layer").Layer<import("ol/source/Source").default>}
+   */
+  // eslint-disable-next-line class-methods-use-this
+  getOLLayer() {
+    throw new Error();
+  }
+
+  /**
+   * @param {import("@vcmap-cesium/engine").SplitDirection} splitDirection
+   */
+  updateSplitDirection(splitDirection) {
+    this.splitDirection = splitDirection;
+    if (this.initialized) {
+      if (
+        this.splitDirection === SplitDirection.NONE &&
+        this._splitDirectionRenderListeners
+      ) {
+        unByKey(this._splitDirectionRenderListeners);
+        this._splitDirectionRenderListeners = null;
+        this.olLayer.changed();
+      } else if (
+        splitDirection !== SplitDirection.NONE &&
+        !this._splitDirectionRenderListeners
+      ) {
+        this._splitDirectionRenderListeners = [];
+        this._splitDirectionRenderListeners.push(
+          /** @type {import("ol/events").EventsKey} */
+          (this.olLayer.on('prerender', this._splitPreRender.bind(this))),
+        );
+        this._splitDirectionRenderListeners.push(
+          /** @type {import("ol/events").EventsKey} */
+          (
+            this.olLayer.on(
+              'postrender',
+              (/** @type {import("ol/render/Event").default} */ event) => {
+                /** @type {CanvasRenderingContext2D} */ (
+                  event.context
+                ).restore();
+              },
+            )
+          ),
+        );
+        this.olLayer.changed();
+      }
+    }
+  }
+
+  /**
+   * @param {import("ol/render/Event").default} event
+   * @private
+   */
+  _splitPreRender(event) {
+    // eslint-disable-next-line prefer-destructuring
+    const context = /** @type {CanvasRenderingContext2D} */ (event.context);
+    const width = context.canvas.width * this.map.splitPosition;
+    context.save();
+    context.beginPath();
+
+    if (this.splitDirection === SplitDirection.LEFT) {
+      context.rect(0, 0, width, context.canvas.height);
+    } else {
+      context.rect(
+        width,
+        0,
+        context.canvas.width - width,
+        context.canvas.height,
+      );
+    }
+    context.clip();
+  }
+
+  /**
+   * @inheritDoc
+   */
+  destroy() {
+    if (this.olLayer) {
+      this.map.removeOLLayer(this.olLayer);
+    }
+    this.olLayer = null;
+    if (this._splitDirectionRenderListeners) {
+      unByKey(this._splitDirectionRenderListeners);
+      this._splitDirectionRenderListeners = null;
+    }
+    super.destroy();
+  }
+}
+
+export default LayerOpenlayersImpl;

package/src/layer/openlayers/openStreetMapOpenlayersImpl.js

@@ -0,0 +1,28 @@
+import Tile from 'ol/layer/Tile.js';
+import OSM from 'ol/source/OSM.js';
+import RasterLayerOpenlayersImpl from './rasterLayerOpenlayersImpl.js';
+
+/**
+ * represents a specific OpenStreetMapLayer layer for openlayers.
+ * @class
+ * @extends {RasterLayerOpenlayersImpl}
+ */
+class OpenStreetMapOpenlayersImpl extends RasterLayerOpenlayersImpl {
+  static get className() {
+    return 'OpenStreetMapOpenlayersImpl';
+  }
+
+  /**
+   * @returns {import("ol/layer/Tile").default}
+   */
+  getOLLayer() {
+    return new Tile({
+      opacity: this.opacity,
+      source: new OSM({
+        maxZoom: this.maxLevel,
+      }),
+    });
+  }
+}
+
+export default OpenStreetMapOpenlayersImpl;

package/src/layer/openlayers/rasterLayerOpenlayersImpl.js

@@ -0,0 +1,44 @@
+import LayerOpenlayersImpl from './layerOpenlayersImpl.js';
+
+/**
+ * RasterLayer implementation for {@link Openlayers}
+ * @class
+ * @extends {LayerOpenlayersImpl}
+ * @implements {RasterLayerImplementation}
+ * @abstract
+ */
+class RasterLayerOpenlayersImpl extends LayerOpenlayersImpl {
+  static get className() {
+    return 'RasterLayerOpenlayersImpl';
+  }
+
+  /**
+   * @param {import("@vcmap/core").OpenlayersMap} map
+   * @param {RasterLayerImplementationOptions} options
+   */
+  constructor(map, options) {
+    super(map, options);
+    /** @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;
+  }
+
+  /**
+   * @param {number} opacity
+   */
+  updateOpacity(opacity) {
+    this.opacity = opacity;
+    if (this.initialized) {
+      this.olLayer.setOpacity(this.opacity);
+    }
+  }
+}
+
+export default RasterLayerOpenlayersImpl;

package/src/{vcs/vcm/layer/openlayers/singleImageOpenlayers.js → layer/openlayers/singleImageOpenlayersImpl.js}

@@ -1,20 +1,21 @@
 import ImageLayer from 'ol/layer/Image.js';
 import ImageStatic from 'ol/source/ImageStatic.js';
-import RasterLayerOpenlayers from './rasterLayerOpenlayers.js';
+import RasterLayerOpenlayersImpl from './rasterLayerOpenlayersImpl.js';
 import { wgs84Projection } from '../../util/projection.js';
 import { isSameOrigin } from '../../util/urlHelpers.js';
 
 /**
  * represents a specific OpenLayers SingleImageLayer Layer class.
  * @class
- * @export
- * @extends {RasterLayerOpenlayers}
+ * @extends {RasterLayerOpenlayersImpl}
  */
-class SingleImageOpenlayers extends RasterLayerOpenlayers {
-  static get className() { return 'vcs.vcm.layer.openlayers.SingleImageOpenlayers'; }
+class SingleImageOpenlayersImpl extends RasterLayerOpenlayersImpl {
+  static get className() {
+    return 'SingleImageOpenlayersImpl';
+  }
 
   /**
-   * @param {import("@vcmap/core").Openlayers} map
+   * @param {import("@vcmap/core").OpenlayersMap} map
    * @param {SingleImageImplementationOptions} options
    */
   constructor(map, options) {
@@ -46,4 +47,4 @@ class SingleImageOpenlayers extends RasterLayerOpenlayers {
   }
 }
 
-export default SingleImageOpenlayers;
+export default SingleImageOpenlayersImpl;

package/src/{vcs/vcm/layer/openlayers/tileDebugOpenlayers.js → layer/openlayers/tileDebugOpenlayersImpl.js}

@@ -1,16 +1,17 @@
 import Tile from 'ol/layer/Tile.js';
 import TileDebug from 'ol/source/TileDebug.js';
-import LayerOpenlayers from './layerOpenlayers.js';
+import LayerOpenlayersImpl from './layerOpenlayersImpl.js';
 
 /**
  * layer Implementation to render tile boundaries.
  * @class
- * @export
- * @extends {LayerOpenlayers}
+ * @extends {LayerOpenlayersImpl}
  * @implements {VectorTileImplementation}
  */
-class TileDebugOpenlayers extends LayerOpenlayers {
-  static get className() { return 'vcs.vcm.layer.openlayers.TileDebugOpenlayers'; }
+class TileDebugOpenlayersImpl extends LayerOpenlayersImpl {
+  static get className() {
+    return 'TileDebugOpenlayersImpl';
+  }
 
   /**
    * @returns {import("ol/layer/Tile").default}
@@ -36,4 +37,4 @@ class TileDebugOpenlayers extends LayerOpenlayers {
   updateTiles(args) {}
 }
 
-export default TileDebugOpenlayers;
+export default TileDebugOpenlayersImpl;

package/src/{vcs/vcm/layer/openlayers/tmsOpenlayers.js → layer/openlayers/tmsOpenlayersImpl.js}

@@ -1,21 +1,22 @@
 import XYZ from 'ol/source/XYZ.js';
 import Tile from 'ol/layer/Tile.js';
 import { mercatorProjection } from '../../util/projection.js';
-import RasterLayerOpenlayers from './rasterLayerOpenlayers.js';
+import RasterLayerOpenlayersImpl from './rasterLayerOpenlayersImpl.js';
 import { TilingScheme } from '../rasterLayer.js';
 import { isSameOrigin } from '../../util/urlHelpers.js';
 
 /**
- * TMS implementation for {@link Openlayers}.
+ * TmsLayer implementation for {@link Openlayers}.
  * @class
- * @export
- * @extends {RasterLayerOpenlayers}
+ * @extends {RasterLayerOpenlayersImpl}
  */
-class TMSOpenlayers extends RasterLayerOpenlayers {
-  static get className() { return 'vcs.vcm.layer.openlayers.TMSOpenlayers'; }
+class TmsOpenlayersImpl extends RasterLayerOpenlayersImpl {
+  static get className() {
+    return 'TmsOpenlayersImpl';
+  }
 
   /**
-   * @param {import("@vcmap/core").Openlayers} map
+   * @param {import("@vcmap/core").OpenlayersMap} map
    * @param {TMSImplementationOptions} options
    */
   constructor(map, options) {
@@ -33,7 +34,7 @@ class TMSOpenlayers extends RasterLayerOpenlayers {
     const sourceOptions = {
       tileUrlFunction: (tileCoord) => {
         const baseUrl = this.url.replace(/\/$/, '');
-        const y = (1 << tileCoord[0]) - (tileCoord[2]) - 1;
+        const y = (1 << tileCoord[0]) - tileCoord[2] - 1;
         return `${baseUrl}/${tileCoord[0]}/${tileCoord[1]}/${y}.${this.format}`;
       },
       tileSize: this.tileSize,
@@ -53,10 +54,11 @@ class TMSOpenlayers extends RasterLayerOpenlayers {
       opacity: this.opacity,
     };
     if (this.extent && this.extent.isValid()) {
-      tileOptions.extent = this.extent.getCoordinatesInProjection(mercatorProjection);
+      tileOptions.extent =
+        this.extent.getCoordinatesInProjection(mercatorProjection);
     }
     return new Tile(tileOptions);
   }
 }
 
-export default TMSOpenlayers;
+export default TmsOpenlayersImpl;

package/src/{vcs/vcm/layer/openlayers/vectorOpenlayers.js → layer/openlayers/vectorOpenlayersImpl.js}

@@ -1,20 +1,20 @@
 import OLVectorLayer from 'ol/layer/Vector.js';
-import LayerOpenlayers from './layerOpenlayers.js';
+import LayerOpenlayersImpl from './layerOpenlayersImpl.js';
 import { synchronizeFeatureVisibilityWithSource } from '../vectorHelpers.js';
-import { getGlobalHider } from '../globalHider.js';
 
 /**
  * represents a specific vectorlayer for openlayers.
  * @class
- * @export
  * @implements {FeatureLayerImplementation}
- * @extends {LayerOpenlayers}
+ * @extends {LayerOpenlayersImpl}
  */
-class VectorOpenlayers extends LayerOpenlayers {
-  static get className() { return 'vcs.vcm.layer.openlayers.VectorOpenlayers'; }
+class VectorOpenlayersImpl extends LayerOpenlayersImpl {
+  static get className() {
+    return 'VectorOpenlayersImpl';
+  }
 
   /**
-   * @param {import("@vcmap/core").Openlayers} map
+   * @param {import("@vcmap/core").OpenlayersMap} map
    * @param {VectorImplementationOptions} options
    */
   constructor(map, options) {
@@ -36,7 +36,8 @@ class VectorOpenlayers extends LayerOpenlayers {
     this._featureVisibilityListeners = [];
     /** @type {import("ol/layer/Vector").default<import("ol/source").Vector<import("ol/geom/Geometry").default>>|null} */
     this.olLayer = null;
-    this.globalHider = getGlobalHider();
+    /** @type {import("@vcmap/core").GlobalHider} */
+    this.globalHider = options.globalHider;
   }
 
   /**
@@ -81,7 +82,11 @@ class VectorOpenlayers extends LayerOpenlayers {
       if (this.active) {
         if (this._featureVisibilityListeners.length === 0) {
           this._featureVisibilityListeners =
-            synchronizeFeatureVisibilityWithSource(this.featureVisibility, this.source, this.globalHider);
+            synchronizeFeatureVisibilityWithSource(
+              this.featureVisibility,
+              this.source,
+              this.globalHider,
+            );
         }
       }
     }
@@ -92,7 +97,9 @@ class VectorOpenlayers extends LayerOpenlayers {
    */
   deactivate() {
     super.deactivate();
-    this._featureVisibilityListeners.forEach((cb) => { cb(); });
+    this._featureVisibilityListeners.forEach((cb) => {
+      cb();
+    });
     this._featureVisibilityListeners = [];
   }
 
@@ -109,10 +116,12 @@ class VectorOpenlayers extends LayerOpenlayers {
    * @inheritDoc
    */
   destroy() {
-    this._featureVisibilityListeners.forEach((cb) => { cb(); });
+    this._featureVisibilityListeners.forEach((cb) => {
+      cb();
+    });
     this._featureVisibilityListeners = [];
     super.destroy();
   }
 }
 
-export default VectorOpenlayers;
+export default VectorOpenlayersImpl;