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

package/src/layer/vectorSymbols.ts

@@ -0,0 +1,41 @@
+/**
+ * Attached to a geometry to indicate, it is already in mercator and not the layers default projection
+ */
+export const alreadyTransformedToMercator: unique symbol = Symbol(
+  'alreadyTransformedToMercator',
+);
+
+/**
+ * Attached to a geometry to indicate, it is already in oblique image coordiantes and not mercator
+ */
+export const alreadyTransformedToImage: unique symbol = Symbol(
+  'alreadyTransformedToImage',
+);
+
+/**
+ * Attached to an ol/Feature to reference the underlying oblique geometry
+ */
+export const obliqueGeometry: unique symbol = Symbol('obliqueGeometry');
+
+/**
+ * Attached to an ol/Feature which should only exist in oblqie coordinates and not be transformed to mercator on change
+ */
+export const doNotTransform: unique symbol = Symbol('doNotTransform');
+
+/**
+ * Attached to oblique features to reference the underlying original ol/Feature
+ */
+export const originalFeatureSymbol: unique symbol = Symbol('OriginalFeature');
+
+/**
+ * Attached to mercator or oblique geometries which are polygons but have a circular counterpart. Used to not
+ * mess up circle drawing in oblique
+ */
+export const actuallyIsCircle: unique symbol = Symbol('ActuallyIsCircle');
+
+/**
+ * Can be attached to features to have the primitives be created sync instead of async. Use this
+ * for faster response times to changes. Do not use this on bulk insertion etc. since sync creation blocks
+ * the rendering thread
+ */
+export const createSync: unique symbol = Symbol('createSync');

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

@@ -1,16 +1,28 @@
-import Style from 'ol/style/Style.js';
+import Style, { type StyleFunction } from 'ol/style/Style.js';
+import type { Feature } from 'ol/index.js';
+import type { Size } from 'ol/size.js';
+
 import { parseInteger } from '@vcsuite/parsers';
 import CesiumMap from '../map/cesiumMap.js';
 import VectorRasterTileCesiumImpl from './cesium/vectorRasterTileCesiumImpl.js';
 import OpenlayersMap from '../map/openlayersMap.js';
 import VectorTileOpenlayersImpl from './openlayers/vectorTileOpenlayersImpl.js';
-import FeatureLayer from './featureLayer.js';
+import FeatureLayer, {
+  FeatureLayerImplementation,
+  FeatureLayerImplementationOptions,
+  FeatureLayerOptions,
+} from './featureLayer.js';
 import VectorStyleItem, {
   defaultVectorStyle,
+  VectorStyleItemOptions,
 } from '../style/vectorStyleItem.js';
-import VectorProperties from './vectorProperties.js';
-import DeclarativeStyleItem from '../style/declarativeStyleItem.js';
-import {
+import VectorProperties, {
+  VectorPropertiesOptions,
+} from './vectorProperties.js';
+import DeclarativeStyleItem, {
+  DeclarativeStyleItemOptions,
+} from '../style/declarativeStyleItem.js';
+import FeatureVisibility, {
   FeatureVisibilityAction,
   globalHidden,
   hidden,
@@ -19,22 +31,30 @@ import {
 import { getStylesArray } from '../util/featureconverter/convert.js';
 import { vcsLayerName } from './layerSymbols.js';
 import TileProviderFeatureProvider from '../featureProvider/tileProviderFeatureProvider.js';
-import { originalFeatureSymbol } from './vectorSymbols.js';
 import {
   getObjectFromClassRegistry,
   layerClassRegistry,
   tileProviderClassRegistry,
 } from '../classRegistry.js';
-import TileProvider from './tileProvider/tileProvider.js';
+import TileProvider, {
+  TileLoadedEvent,
+  type TileProviderOptions,
+  TileProviderRtree,
+} from './tileProvider/tileProvider.js';
+import GlobalHider from './globalHider.js';
+import Extent from '../util/extent.js';
+import VcsMap from '../map/vcsMap.js';
+import StyleItem from '../style/styleItem.js';
 
 /**
  * synchronizes featureVisibility Symbols on the feature;
- * @param {import("@vcmap/core").FeatureVisibility} featureVisibility
- * @param {import("@vcmap/core").GlobalHider} globalHider
- * @param {import("ol").Feature<import("ol/geom/Geometry").default>} feature
  */
-function synchronizeFeatureVisibility(featureVisibility, globalHider, feature) {
-  const featureId = feature.getId();
+function synchronizeFeatureVisibility(
+  featureVisibility: FeatureVisibility,
+  globalHider: GlobalHider | undefined,
+  feature: Feature,
+): void {
+  const featureId = feature.getId() as string | number;
   if (featureVisibility.hiddenObjects[featureId]) {
     feature[hidden] = true;
   } else if (feature[hidden]) {
@@ -46,58 +66,55 @@ function synchronizeFeatureVisibility(featureVisibility, globalHider, feature) {
   } else if (feature[highlighted]) {
     delete feature[highlighted];
   }
-  if (globalHider.hiddenObjects[featureId]) {
+  if (globalHider?.hiddenObjects[featureId]) {
     feature[globalHidden] = true;
   } else if (feature[globalHidden]) {
     delete feature[globalHidden];
   }
 }
 
-/**
- * @typedef {FeatureLayerOptions} VectorTileOptions
- * @property {TileProviderOptions|import("@vcmap/core").TileProvider} tileProvider
- * @property {VectorStyleItemOptions|import("@vcmap/core").VectorStyleItem|undefined} highlightStyle
- * @property {VectorPropertiesOptions|undefined} vectorProperties
- * @property {number|undefined} minLevel used to restrict the zoom level visibility (minlevel does not allow rendering above tileProvider baseLevel)
- * @property {number|undefined} maxLevel used to restrict the zoom level visibility
- * @api
- */
-
-/**
- * @typedef {FeatureLayerImplementationOptions} VectorTileImplementationOptions
- * @property {import("@vcmap/core").TileProvider} tileProvider
- * @property {import("ol/size").Size} tileSize
- * @property {number} minLevel
- * @property {number} maxLevel
- * @property {import("@vcmap/core").Extent|undefined} extent
- */
-
-/**
- * @typedef {FeatureLayerImplementation} VectorTileImplementation
- * @property {function(Array<string>):void} updateTiles
- */
+export type VectorTileOptions = FeatureLayerOptions & {
+  tileProvider?: TileProviderOptions | TileProvider;
+  highlightStyle?: VectorStyleItemOptions | VectorStyleItem;
+  vectorProperties?: VectorPropertiesOptions;
+  /**
+   * used to restrict the zoom level visibility (minlevel does not allow rendering above tileProvider baseLevel)
+   */
+  minLevel?: number;
+  /**
+   * used to restrict the zoom level visibility
+   */
+  maxLevel?: number;
+};
+
+export type VectorTileImplementationOptions =
+  FeatureLayerImplementationOptions & {
+    tileProvider: TileProvider;
+    tileSize: Size;
+    minLevel: number;
+    maxLevel: number;
+    extent?: Extent;
+  };
+
+export interface VectorTileImplementation extends FeatureLayerImplementation {
+  updateTiles(tiles: string[]): void;
+}
 
 /**
  * VectorTileLayer Layer for tiled vector Data. Can be connected to data with a TileProvider
- * @class
- * @extends {FeatureLayer}
- * @api stable
  */
-class VectorTileLayer extends FeatureLayer {
-  /**
-   * @readonly
-   * @returns {string}
-   */
-  static get className() {
+class VectorTileLayer extends FeatureLayer<
+  VectorTileOpenlayersImpl | VectorRasterTileCesiumImpl
+> {
+  static get className(): string {
     return 'VectorTileLayer';
   }
 
-  /**
-   * @returns {VectorTileOptions}
-   */
-  static getDefaultOptions() {
+  static getDefaultOptions(): VectorTileOptions {
     return {
       ...FeatureLayer.getDefaultOptions(),
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-ignore
       tileProvider: undefined,
       highlightStyle: undefined,
       vectorProperties: {},
@@ -106,20 +123,45 @@ class VectorTileLayer extends FeatureLayer {
     };
   }
 
+  highlightStyle: VectorStyleItem | undefined;
+
+  private _tileSize: Size = [256, 256];
+
   /**
-   * @param {VectorTileOptions} options
+   * at the moment only used for allowPicking, triggers a reload on change
    */
-  constructor(options) {
+  vectorProperties: VectorProperties;
+
+  tileProvider: TileProvider;
+
+  private _maxLevel: number;
+
+  private _minLevel: number;
+
+  private _featureVisibilityListeners: (() => void)[] = [];
+
+  // eslint-disable-next-line class-methods-use-this
+  private _tileLoadEventListener: () => void = () => {};
+
+  // eslint-disable-next-line class-methods-use-this
+  private _vectorPropertiesChangedListener: () => void = () => {};
+
+  /**
+   * zIndex for features with featureStyle // Do we maybe need a global counter ?
+   */
+  private _styleZIndex = 0;
+
+  /**
+   * @param  options
+   */
+  constructor(options: VectorTileOptions) {
     super(options);
 
     this._supportedMaps = [CesiumMap.className, OpenlayersMap.className];
 
     const defaultOptions = VectorTileLayer.getDefaultOptions();
 
-    /** @type {VectorStyleItem} */
-    this.highlightStyle = /** @type {undefined} */ (
-      defaultOptions.highlightStyle
-    );
+    this.highlightStyle = undefined;
     if (options.highlightStyle) {
       this.highlightStyle =
         options.highlightStyle instanceof VectorStyleItem
@@ -127,99 +169,41 @@ class VectorTileLayer extends FeatureLayer {
           : new VectorStyleItem(options.highlightStyle);
     }
 
-    /**
-     * @type {import("ol/size").Size}
-     * @private
-     */
-    this._tileSize = [256, 256];
-
-    /**
-     * at the moment only used for allowPicking, triggers a reload on change
-     * @type {VectorProperties}
-     * @api
-     */
     this.vectorProperties = new VectorProperties({
       allowPicking: this.allowPicking,
       ...options.vectorProperties,
     });
 
-    /**
-     * @type {import("@vcmap/core").TileProvider}
-     * @api
-     */
     this.tileProvider =
       options.tileProvider instanceof TileProvider // XXX this now throws if not passing in a tileProvider.
         ? options.tileProvider
-        : getObjectFromClassRegistry(
+        : (getObjectFromClassRegistry(
             tileProviderClassRegistry,
-            options.tileProvider,
-          );
+            options.tileProvider ?? { type: TileProvider.className },
+          ) as TileProvider);
     if (this.tileProvider) {
       this.tileProvider.locale = this.locale;
     }
 
-    /**
-     * @type {number|undefined}
-     * @private
-     */
     this._maxLevel = parseInteger(options.maxLevel, defaultOptions.maxLevel);
-
-    /**
-     * @type {number|undefined}
-     * @private
-     */
     this._minLevel = parseInteger(options.minLevel, defaultOptions.minLevel);
-
-    /**
-     * @type {Array<Function>}
-     * @private
-     */
-    this._featureVisibilityListeners = [];
-
-    /**
-     * @type {Function}
-     * @private
-     */
-    this._tileLoadEventListener = () => {};
-
-    /**
-     * @type {Function}
-     * @private
-     */
-    this._vectorPropertiesChangedListener = () => {};
-
-    /**
-     * zIndex for features with featureStyle // Do we maybe need a global counter ?
-     * @type {number}
-     * @private
-     */
-    this._styleZIndex = 0;
   }
 
   /**
    * returns the currently set locale. Can be used to provide locale specific URLs.
-   * @type {string}
    */
-  get locale() {
+  get locale(): string {
     return super.locale;
   }
 
-  /**
-   * sets the locale and reloads the layer the if the URL is a locale aware Object.
-   * @param {string} value
-   */
-  set locale(value) {
+  set locale(value: string) {
     if (this.tileProvider) {
       this.tileProvider.locale = super.locale;
     }
     super.locale = value;
   }
 
-  /**
-   * initializes the layer, can be used to defer loading
-   * @returns {Promise<void>}
-   */
-  async initialize() {
+  async initialize(): Promise<void> {
     if (!this.initialized) {
       this._tileLoadEventListener =
         this.tileProvider.tileLoadedEvent.addEventListener((event) =>
@@ -227,7 +211,8 @@ class VectorTileLayer extends FeatureLayer {
         );
       this._vectorPropertiesChangedListener =
         this.vectorProperties.propertyChanged.addEventListener(() => {
-          this.reload();
+          // eslint-disable-next-line no-void
+          void this.reload();
         });
       this.featureProvider = new TileProviderFeatureProvider(this.name, {
         // XXX this overwrites
@@ -238,53 +223,25 @@ class VectorTileLayer extends FeatureLayer {
     await super.initialize();
   }
 
-  /**
-   * @param {import("ol").Feature<import("ol/geom/Geometry").default>} olFeature
-   * @returns {?Object}
-   */
-  objectClickedHandler(olFeature) {
-    const actualFeature = olFeature[originalFeatureSymbol] || olFeature;
-    if (this.vectorProperties.getAllowPicking(actualFeature)) {
-      if (olFeature[hidden] || olFeature[globalHidden]) {
-        return null;
-      }
-      return {
-        id: actualFeature.getId(),
-        feature: actualFeature,
-      };
-    }
-    return null;
-  }
-
-  /**
-   * @returns {number}
-   * @private
-   */
-  _getNextStyleZIndex() {
+  private _getNextStyleZIndex(): number {
     this._styleZIndex += 1;
     return this._styleZIndex;
   }
 
-  /**
-   * @param {TileLoadedEvent} event
-   * @private
-   */
-  _handleTileLoaded({ rtree }) {
+  private _handleTileLoaded({ rtree }: TileLoadedEvent): void {
     rtree
       .all()
       .map((item) => item.value)
       .forEach((feature) => {
-        const featureStyle = /** @type {import("ol/style/Style").default} */ (
-          feature.getStyle()
-        );
+        const featureStyle = feature.getStyle();
         if (featureStyle && featureStyle instanceof Style) {
           featureStyle.setZIndex(this._getNextStyleZIndex());
         }
         feature[vcsLayerName] = this.name;
-        feature.getStyleFunction = () => {
-          return this._featureStyle.bind(this);
+        feature.getStyleFunction = (): StyleFunction => {
+          return this._featureStyle.bind(this) as StyleFunction;
         };
-        if (this.tileProvider.trackFeaturesToTiles) {
+        if (this.tileProvider.trackFeaturesToTiles && this.globalHider) {
           synchronizeFeatureVisibility(
             this.featureVisibility,
             this.globalHider,
@@ -294,19 +251,15 @@ class VectorTileLayer extends FeatureLayer {
       });
   }
 
-  /**
-   * @param {import("@vcmap/core").GlobalHider} globalHider
-   */
-  setGlobalHider(globalHider) {
+  setGlobalHider(globalHider: GlobalHider): void {
     super.setGlobalHider(globalHider);
     this._setupFeatureVisibilityHandlers();
   }
 
   /**
    * Sets up listeners for featureVisibility and global hider
-   * @private
    */
-  _setupFeatureVisibilityHandlers() {
+  private _setupFeatureVisibilityHandlers(): void {
     if (!this.tileProvider.trackFeaturesToTiles) {
       return;
     }
@@ -316,12 +269,16 @@ class VectorTileLayer extends FeatureLayer {
 
     this._featureVisibilityListeners = [
       this.featureVisibility.changed.addEventListener(({ action, ids }) => {
-        const tileIdsChanged = new Set();
+        const tileIdsChanged: Set<string> = new Set();
         ids.forEach((id) => {
-          const tileIds = this.tileProvider.featureIdToTileIds.get(id);
+          const tileIds = this.tileProvider.featureIdToTileIds.get(
+            id as string,
+          );
           if (tileIds) {
             tileIds.forEach((tileId) => {
-              const rtree = this.tileProvider.rtreeCache.get(tileId);
+              const rtree = this.tileProvider.rtreeCache.get(
+                tileId,
+              ) as TileProviderRtree;
               const tileProviderRTreeEntry = rtree
                 .all()
                 .find((item) => item.value.getId() === id);
@@ -349,12 +306,16 @@ class VectorTileLayer extends FeatureLayer {
     if (this.globalHider) {
       this._featureVisibilityListeners.push(
         this.globalHider.changed.addEventListener(({ action, ids }) => {
-          const tileIdsChanged = new Set();
+          const tileIdsChanged: Set<string> = new Set();
           ids.forEach((id) => {
-            const tileIds = this.tileProvider.featureIdToTileIds.get(id);
+            const tileIds = this.tileProvider.featureIdToTileIds.get(
+              id as string,
+            );
             if (tileIds) {
               tileIds.forEach((tileId) => {
-                const rtree = this.tileProvider.rtreeCache.get(tileId);
+                const rtree = this.tileProvider.rtreeCache.get(
+                  tileId,
+                ) as TileProviderRtree;
                 const tileProviderRTreeEntry = rtree
                   .all()
                   .find((item) => item.value.getId() === id);
@@ -379,23 +340,17 @@ class VectorTileLayer extends FeatureLayer {
   /**
    * rerenders the specified tiles
    * rendering happens async
-   * @param {Array<string>} tileIds
-   * @api
    */
-  updateTiles(tileIds) {
+  updateTiles(tileIds: string[]): void {
     this.getImplementations().forEach((impl) => {
-      /** @type {VectorTileImplementation} */ (impl).updateTiles(tileIds);
+      impl.updateTiles(tileIds);
     });
   }
 
   /**
    * calculates the style the feature has to be rendered
-   * @param {import("ol").Feature<import("ol/geom/Geometry").default>} feature
-   * @param {number} resolution
-   * @returns {Array<import("ol/style/Style").default>}
-   * @private
    */
-  _featureStyle(feature, resolution) {
+  private _featureStyle(feature: Feature, resolution: number): Style[] {
     let style;
     if (feature[hidden] || feature[globalHidden]) {
       return [];
@@ -413,26 +368,20 @@ class VectorTileLayer extends FeatureLayer {
     return getStylesArray(style, feature, resolution);
   }
 
-  /**
-   * @returns {VectorTileImplementationOptions}
-   */
-  getImplementationOptions() {
+  getImplementationOptions(): VectorTileImplementationOptions {
     return {
       ...super.getImplementationOptions(),
       tileProvider: this.tileProvider,
       tileSize: this._tileSize,
       minLevel: this._minLevel,
       maxLevel: this._maxLevel,
-      extent: this.extent,
+      extent: this.extent ?? new Extent(),
     };
   }
 
-  /**
-   * @inheritDoc
-   * @param {import("@vcmap/core").VcsMap} map
-   * @returns {Array<VectorRasterTileCesiumImpl|VectorTileOpenlayersImpl>}
-   */
-  createImplementationsForMap(map) {
+  createImplementationsForMap(
+    map: VcsMap,
+  ): (VectorRasterTileCesiumImpl | VectorTileOpenlayersImpl)[] {
     if (map instanceof CesiumMap) {
       return [
         new VectorRasterTileCesiumImpl(map, this.getImplementationOptions()),
@@ -448,27 +397,23 @@ class VectorTileLayer extends FeatureLayer {
     return [];
   }
 
-  /**
-   * @param {(DeclarativeStyleItemOptions|VectorStyleItemOptions|import("@vcmap/core").StyleItem)=} styleOptions
-   * @param {VectorStyleItem=} defaultStyle
-   * @returns {import("@vcmap/core").StyleItem}
-   */
-  getStyleOrDefaultStyle(styleOptions, defaultStyle) {
+  getStyleOrDefaultStyle(
+    styleOptions?:
+      | DeclarativeStyleItemOptions
+      | VectorStyleItemOptions
+      | StyleItem,
+    defaultStyle?: VectorStyleItem,
+  ): StyleItem {
     return super.getStyleOrDefaultStyle(
       styleOptions,
       defaultStyle || defaultVectorStyle.clone(),
     );
   }
 
-  /**
-   * @inheritDoc
-   * @returns {Promise<void>}
-   * @api stable
-   */
-  async activate() {
+  async activate(): Promise<void> {
     await super.activate();
     this._setupFeatureVisibilityHandlers();
-    if (this.tileProvider.trackFeaturesToTiles && this.globalHider) {
+    if (this.tileProvider.trackFeaturesToTiles) {
       this.tileProvider.forEachFeature((feature) => {
         synchronizeFeatureVisibility(
           this.featureVisibility,
@@ -479,22 +424,14 @@ class VectorTileLayer extends FeatureLayer {
     }
   }
 
-  /**
-   * @inheritDoc
-   * @api
-   */
-  deactivate() {
+  deactivate(): void {
     super.deactivate();
     this._featureVisibilityListeners.forEach((cb) => {
       cb();
     });
   }
 
-  /**
-   * @inheritDoc
-   * @api
-   */
-  destroy() {
+  destroy(): void {
     this._featureVisibilityListeners.forEach((cb) => {
       cb();
     });
@@ -512,12 +449,8 @@ class VectorTileLayer extends FeatureLayer {
     }
   }
 
-  /**
-   * @inheritDoc
-   * @returns {VectorTileOptions}
-   */
-  toJSON() {
-    const config = /** @type {VectorTileOptions} */ (super.toJSON());
+  toJSON(): VectorTileOptions {
+    const config: VectorTileOptions = super.toJSON();
     const defaultOptions = VectorTileLayer.getDefaultOptions();
 
     if (this._maxLevel !== defaultOptions.maxLevel) {