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

package/src/featureProvider/{wmsFeatureProvider.js → wmsFeatureProvider.ts}

@@ -1,32 +1,75 @@
 import GML2 from 'ol/format/GML2.js';
+import type { Options as GMLOptions } from 'ol/format/GMLBase.js';
 import WFS from 'ol/format/WFS.js';
-import GeoJSON from 'ol/format/GeoJSON.js';
+import GeoJSON, {
+  type GeoJSONObject,
+  type Options as GeoJSONOptions,
+} from 'ol/format/GeoJSON.js';
 import GML3 from 'ol/format/GML3.js';
 import Point from 'ol/geom/Point.js';
-import { getTransform } from 'ol/proj.js';
+import { getTransform, type Projection as OLProjection } from 'ol/proj.js';
+import type { Size } from 'ol/size.js';
+import type { Feature } from 'ol/index.js';
+import type { Coordinate } from 'ol/coordinate.js';
+import type { TileWMS } from 'ol/source.js';
+import type FeatureFormat from 'ol/format/Feature.js';
 import { parseInteger } from '@vcsuite/parsers';
-import AbstractFeatureProvider from './abstractFeatureProvider.js';
-import Projection, { mercatorProjection } from '../util/projection.js';
+import AbstractFeatureProvider, {
+  AbstractFeatureProviderOptions,
+} from './abstractFeatureProvider.js';
+import Projection, {
+  mercatorProjection,
+  ProjectionOptions,
+} from '../util/projection.js';
+import type { WMSSourceOptions } from '../layer/wmsHelpers.js';
 import { getWMSSource } from '../layer/wmsHelpers.js';
-import Extent from '../util/extent.js';
+import Extent, { ExtentOptions } from '../util/extent.js';
 import { requestJson } from '../util/fetch.js';
 import { featureProviderClassRegistry } from '../classRegistry.js';
+import { TilingScheme } from '../layer/rasterLayer.js';
 
-/**
- * @typedef {AbstractFeatureProviderOptions} WMSFeatureProviderOptions
- * @property {string|undefined} [responseType='text/xml'] - the response type for the feature info
- * @property {Object|undefined} formatOptions - format options for the GeojsonLayer, WfsLayer or GML format. To overwrite the gmlFormat option in WfsLayer format, use 'GML', 'GML2' or 'GML3' as string
- * @property {ProjectionOptions|undefined} projection - the projection of the data, if not encoded in the response
- * @property {string} url
- * @property {string} [tilingSchema='geographic'] -  either "geographic" or "mercator"
- * @property {number} [maxLevel=18]
- * @property {number} [minLevel=0]
- * @property {import("ol/size").Size} [tileSize=[256,256]]
- * @property {Extent|ExtentOptions|undefined} extent
- * @property {Object<string, string>} parameters
- * @property {string} [version='1.1.1']
- * @api
- */
+export type FormatOptions = GeoJSONOptions &
+  GMLOptions &
+  Record<string, unknown> & { gmlFormat?: keyof typeof gmlFormats };
+
+export type WMSFeatureProviderOptions = AbstractFeatureProviderOptions & {
+  /**
+   * the response type for the feature info
+   * @default 'text/xml'
+   */
+  responseType?: string;
+  /**
+   * format options for the GeojsonLayer, WfsLayer or GML format. To overwrite the gmlFormat option in WfsLayer format, use 'GML', 'GML2' or 'GML3' as string
+   */
+  formatOptions?: FormatOptions;
+  /**
+   * the projection of the data, if not encoded in the response
+   */
+  projection?: ProjectionOptions;
+  url: string;
+  /**
+   * @default {@link TilingScheme.GEOGRAPHIC}
+   */
+  tilingSchema?: TilingScheme;
+  /**
+   * @default 18
+   */
+  maxLevel?: number;
+  /**
+   * @default 0
+   */
+  minLevel?: number;
+  /**
+   * @default [256, 256]
+   */
+  tileSize?: Size;
+  extent?: Extent | ExtentOptions;
+  parameters: Record<string, string>;
+  /**
+   * @default '1.1.1'
+   */
+  version?: string;
+};
 
 const gmlFormats = {
   GML: GML3,
@@ -34,10 +77,6 @@ const gmlFormats = {
   GML3,
 };
 
-/**
- * @type {Array<string>}
- * @const
- */
 const geojsonFormats = [
   'application/geojson',
   'application/json',
@@ -45,17 +84,15 @@ const geojsonFormats = [
   'application/geo+json',
 ];
 
-/**
- * @param {string} responseType
- * @param {Object} options
- * @returns {null|import("ol/format/Feature").default}
- */
-export function getFormat(responseType, options = {}) {
+export function getFormat(
+  responseType: string,
+  options: FormatOptions = {},
+): null | FeatureFormat {
   if (responseType === 'text/xml') {
-    options.gmlFormat = options.gmlFormat
+    const gmlFormat: GML3 | GML2 = options.gmlFormat
       ? new gmlFormats[options.gmlFormat]()
       : new GML2();
-    return new WFS(options);
+    return new WFS({ ...options, gmlFormat });
   }
   if (geojsonFormats.includes(responseType)) {
     return new GeoJSON(options);
@@ -72,19 +109,12 @@ export function getFormat(responseType, options = {}) {
   return null;
 }
 
-/**
- * @class
- * @extends {AbstractFeatureProvider}
- */
 class WMSFeatureProvider extends AbstractFeatureProvider {
-  static get className() {
+  static get className(): string {
     return 'WMSFeatureProvider';
   }
 
-  /**
-   * @returns {WMSFeatureProviderOptions}
-   */
-  static getDefaultOptions() {
+  static getDefaultOptions(): WMSFeatureProviderOptions {
     return {
       ...AbstractFeatureProvider.getDefaultOptions(),
       responseType: 'text/xml',
@@ -92,7 +122,7 @@ class WMSFeatureProvider extends AbstractFeatureProvider {
       formatOptions: undefined,
       projection: undefined,
       url: '',
-      tilingSchema: 'geographic',
+      tilingSchema: TilingScheme.GEOGRAPHIC,
       version: '1.1.1',
       maxLevel: 0,
       minLevel: 0,
@@ -102,18 +132,36 @@ class WMSFeatureProvider extends AbstractFeatureProvider {
     };
   }
 
+  extent: Extent | null = null;
+
+  private _wmsSourceOptions: WMSSourceOptions;
+
+  /**
+   * The WmsLayer Source used to generate getFeatureInfo urls
+   */
+  private _wmsSource: TileWMS | undefined;
+
+  /**
+   * The response type of the get feature info response, e.g. text/xml
+   */
+  featureInfoResponseType: string;
+
+  private _formatOptions: FormatOptions | undefined;
+
+  /**
+   * The feature response format determined by the response type. Use formatOptions to configure the underlying ol.format.Feature
+   */
+  featureFormat: FeatureFormat | null;
+
   /**
-   * @param {string} layerName
-   * @param {WMSFeatureProviderOptions} options
+   * The feature response projection, if not present in the response format.
    */
-  constructor(layerName, options) {
+  projection: Projection | undefined;
+
+  constructor(layerName: string, options: WMSFeatureProviderOptions) {
     super(layerName, options);
     const defaultOptions = WMSFeatureProvider.getDefaultOptions();
 
-    /**
-     * @type {import("@vcmap/core").Extent|null}
-     */
-    this.extent = null;
     if (options.extent) {
       if (options.extent instanceof Extent) {
         this.extent = options.extent;
@@ -121,71 +169,53 @@ class WMSFeatureProvider extends AbstractFeatureProvider {
         this.extent = new Extent(options.extent);
       }
     }
-    /** @type {WMSSourceOptions} */
     this._wmsSourceOptions = {
       url: options.url,
-      tilingSchema: options.tilingSchema || defaultOptions.tilingSchema,
+      tilingSchema:
+        options.tilingSchema || (defaultOptions.tilingSchema as TilingScheme),
       maxLevel: parseInteger(options.maxLevel, defaultOptions.maxLevel),
       minLevel: parseInteger(options.minLevel, defaultOptions.minLevel),
-      tileSize: options.tileSize || defaultOptions.tileSize,
+      tileSize: options.tileSize || (defaultOptions.tileSize as Size),
       parameters: options.parameters,
-      version: options.version || defaultOptions.version,
+      version: options.version || (defaultOptions.version as string),
     };
-    /**
-     * The WmsLayer Source used to generate getFeatureInfo urls
-     * @type {import("ol/source/TileWMS").default}
-     * @api
-     */
-    this.wmsSource = getWMSSource(this._wmsSourceOptions);
-    /**
-     * The response type of the get feature info response, e.g. text/xml
-     * @type {string}
-     * @api
-     */
+
+    this._wmsSource = getWMSSource(this._wmsSourceOptions);
     this.featureInfoResponseType =
-      options.responseType || defaultOptions.responseType;
-    /**
-     * @type {Object}
-     * @private
-     */
+      options.responseType || (defaultOptions.responseType as string);
+
     this._formatOptions = options.formatOptions || defaultOptions.formatOptions;
-    /**
-     * The feature response format determined by the response type. Use formatOptions to configure the underlying ol.format.Feature
-     * @type {import("ol/format/Feature").default}
-     * @api
-     */
     this.featureFormat = getFormat(
       this.featureInfoResponseType,
       options.formatOptions,
     );
-    /**
-     * The feature response projection, if not present in the response format.
-     * @type {Projection}
-     * @api
-     */
     this.projection = options.projection
       ? new Projection(options.projection)
       : undefined;
   }
 
-  /**
-   * @param {import("ol/format/GeoJSON").GeoJSONObject} data
-   * @param {import("ol/coordinate").Coordinate} coordinate
-   * @returns {Array<import("ol").Feature<import("ol/geom/Geometry").default>>}
-   */
-  featureResponseCallback(data, coordinate) {
-    /** @type {Array<import("ol").Feature<import("ol/geom/Geometry").default>>} */
-    let features;
+  get wmsSource(): TileWMS {
+    if (!this._wmsSource) {
+      throw new Error('Accessing destroyed WMSFeatureProvider');
+    }
+    return this._wmsSource;
+  }
+
+  set wmsSource(source: TileWMS) {
+    this._wmsSource = source;
+  }
+
+  featureResponseCallback(
+    data: GeoJSONObject,
+    coordinate: Coordinate,
+  ): Feature[] {
+    let features: Feature[];
 
     try {
-      features =
-        /** @type {Array<import("ol").Feature<import("ol/geom/Geometry").default>>} */
-        (
-          this.featureFormat.readFeatures(data, {
-            dataProjection: this.projection ? this.projection.proj : undefined,
-            featureProjection: mercatorProjection.proj,
-          })
-        );
+      features = this.featureFormat!.readFeatures(data, {
+        dataProjection: this.projection ? this.projection.proj : undefined,
+        featureProjection: mercatorProjection.proj,
+      }) as Feature[];
     } catch (ex) {
       this.getLogger().warning(
         'Features could not be read, please verify the featureInfoResponseType with the capabilities from the server',
@@ -206,14 +236,11 @@ class WMSFeatureProvider extends AbstractFeatureProvider {
     return [];
   }
 
-  /**
-   * @inheritDoc
-   * @param {import("ol/coordinate").Coordinate} coordinate
-   * @param {number} resolution
-   * @returns {Promise<Array<import("ol").Feature<import("ol/geom/Geometry").default>>>}
-   */
-  async getFeaturesByCoordinate(coordinate, resolution) {
-    const projection = this.wmsSource.getProjection();
+  async getFeaturesByCoordinate(
+    coordinate: Coordinate,
+    resolution: number,
+  ): Promise<Feature[]> {
+    const projection = this.wmsSource.getProjection() as OLProjection;
     let coords = coordinate;
     if (projection) {
       const transform = getTransform(mercatorProjection.proj, projection);
@@ -230,9 +257,9 @@ class WMSFeatureProvider extends AbstractFeatureProvider {
     );
 
     if (url) {
-      let data;
+      let data: GeoJSONObject;
       try {
-        data = await requestJson(url);
+        data = await requestJson<GeoJSONObject>(url);
       } catch (ex) {
         this.getLogger().error(`Failed fetching WMS FeatureInfo ${url}`);
         return [];
@@ -244,12 +271,8 @@ class WMSFeatureProvider extends AbstractFeatureProvider {
     return [];
   }
 
-  /**
-   * @inheritDoc
-   * @returns {WMSFeatureProviderOptions}
-   */
-  toJSON() {
-    const config = /** @type {WMSFeatureProviderOptions} */ (super.toJSON());
+  toJSON(): WMSFeatureProviderOptions {
+    const config: Partial<WMSFeatureProviderOptions> = super.toJSON();
     const defaultOptions = WMSFeatureProvider.getDefaultOptions();
     if (this.featureInfoResponseType !== defaultOptions.responseType) {
       config.responseType = this.featureInfoResponseType;
@@ -259,7 +282,7 @@ class WMSFeatureProvider extends AbstractFeatureProvider {
       config.formatOptions = { ...this._formatOptions };
     }
 
-    if (this.projection !== defaultOptions.projection) {
+    if (this.projection) {
       config.projection = this.projection.toJSON();
     }
 
@@ -279,8 +302,8 @@ class WMSFeatureProvider extends AbstractFeatureProvider {
       config.version = this._wmsSourceOptions.version;
     }
     if (
-      this._wmsSourceOptions.tileSize[0] !== defaultOptions.tileSize[0] ||
-      this._wmsSourceOptions.tileSize[1] !== defaultOptions.tileSize[1]
+      this._wmsSourceOptions.tileSize[0] !== defaultOptions?.tileSize?.[0] ||
+      this._wmsSourceOptions.tileSize[1] !== defaultOptions?.tileSize?.[1]
     ) {
       config.tileSize = this._wmsSourceOptions.tileSize.slice();
     }
@@ -288,15 +311,12 @@ class WMSFeatureProvider extends AbstractFeatureProvider {
       config.extent = this.extent.toJSON();
     }
 
-    return config;
+    return config as WMSFeatureProviderOptions;
   }
 
-  /**
-   * @inheritDoc
-   */
-  destroy() {
-    this.wmsSource = undefined;
-    this.featureFormat = undefined;
+  destroy(): void {
+    this._wmsSource = undefined;
+    this.featureFormat = null;
     this.projection = undefined;
     this._formatOptions = undefined;
     super.destroy();

package/src/global.d.ts

@@ -0,0 +1,12 @@
+import type VcsApp from './vcsApp.js';
+import { mouseOverSymbol } from './util/editor/editorSymbols.js';
+
+declare global {
+  interface Window {
+    vcs: { apps: Map<string, VcsApp> };
+    opera?: string;
+  }
+  interface CSSStyleDeclaration {
+    [mouseOverSymbol]?: string;
+  }
+}

package/src/interaction/abstractInteraction.ts

@@ -0,0 +1,191 @@
+import { v4 as uuidv4 } from 'uuid';
+import type {
+  Cartesian2,
+  Cesium3DTileFeature,
+  Cesium3DTilePointFeature,
+  Entity,
+  Ray,
+} from '@vcmap-cesium/engine';
+import type { Coordinate } from 'ol/coordinate.js';
+import type { Feature } from 'ol';
+import {
+  EventType,
+  ModificationKeyType,
+  PointerEventType,
+  PointerKeyType,
+} from './interactionType.js';
+import type VcsMap from '../map/vcsMap.js';
+
+export type MapEvent = {
+  pointerEvent: PointerEventType;
+  map: VcsMap;
+  windowPosition: Cartesian2;
+  key: ModificationKeyType;
+  pointer: PointerKeyType;
+  /**
+   * position in web mercator coordinates
+   */
+  position?: Coordinate;
+  /**
+   * position in web mercator coordinates or image coordinates in ObliqueMap Map Mode
+   */
+  positionOrPixel?: Coordinate;
+  multipleTouch?: boolean;
+  time?: number | null;
+};
+
+export type ObliqueParameters = {
+  /**
+   * the image pixel clicked
+   */
+  pixel: import('ol/coordinate.js').Coordinate;
+  /**
+   * true if the terrain could not be taken into account
+   */
+  estimate?: boolean;
+};
+
+export type EventFeature =
+  | Feature
+  | Cesium3DTileFeature
+  | Cesium3DTilePointFeature
+  | Entity;
+
+export type InteractionEvent = MapEvent & {
+  type: EventType;
+  /**
+   * a potential feature at said location
+   */
+  feature?: EventFeature;
+  /**
+   * if set to true, the event chain is interrupted
+   */
+  stopPropagation?: boolean;
+  /**
+   * additional parameters from oblique if obliquemode is active
+   */
+  obliqueParameters?: ObliqueParameters;
+  ray?: Ray;
+  /**
+   * whether the position is exact, eg with translucentDepthPicking on
+   */
+  exactPosition?: boolean;
+};
+
+export type EventAfterEventHandler = Omit<
+  InteractionEvent,
+  'position' | 'positionOrPixel'
+> & { position: Coordinate; positionOrPixel: Coordinate };
+
+/**
+ * An abstract interface for all interactions
+ */
+class AbstractInteraction {
+  /**
+   * A unique identifier for this interaction
+   */
+  id: string;
+
+  private _defaultActive: number;
+
+  /**
+   * The current active bitmask for {@link EventType}
+   */
+  active: number;
+
+  private _defaultModificationKey: ModificationKeyType;
+
+  /**
+   * The current active {@link ModificationKeyType}
+   */
+  modificationKey: ModificationKeyType;
+
+  private _defaultPointerKey: PointerKeyType;
+
+  /**
+   * The currently active {@link PointerKeyType}
+   */
+  pointerKey: PointerKeyType;
+
+  /**
+   * @param  [defaultActive=EventType.NONE] - A bitmask representing the default  to listen to
+   * @param  [defaultModificationKey=ModificationKeyType.NONE] - A bitmask representing the default  keys to listen to
+   * @param  [defaultPointerKey=PointerKeyType.LEFT] - A bitmask representing the  pointer key to listen to
+   */
+  constructor(
+    defaultActive: EventType = EventType.NONE,
+    defaultModificationKey: ModificationKeyType = ModificationKeyType.NONE,
+    defaultPointerKey: PointerKeyType = PointerKeyType.LEFT,
+  ) {
+    this.id = uuidv4();
+    this._defaultActive = defaultActive;
+    this.active = this._defaultActive;
+    this._defaultModificationKey = defaultModificationKey;
+    this.modificationKey = this._defaultModificationKey;
+    this._defaultPointerKey = defaultPointerKey;
+    this.pointerKey = this._defaultPointerKey;
+  }
+
+  /**
+   * Main function, called when an event is raised for this interaction
+   */
+  // eslint-disable-next-line class-methods-use-this
+  pipe(event: InteractionEvent): Promise<InteractionEvent> {
+    return Promise.resolve(event);
+  }
+
+  /**
+   * Called when the modifier keys have changed.
+   */
+  // eslint-disable-next-line class-methods-use-this,no-unused-vars
+  modifierChanged(_modifier: ModificationKeyType): void {}
+
+  /**
+   * Sets the interaction active.
+   * Use boolean (true|false) to toggle default behavior.
+   * Pass it a bitmask of {@link EventType}
+   * to change the active state.
+   * Call without arguments to reset the default active, modification key and pointer Key behavior
+   */
+  setActive(active?: boolean | number): void {
+    if (typeof active === 'undefined') {
+      this.active = this._defaultActive;
+      this.modificationKey = this._defaultModificationKey;
+      this.pointerKey = this._defaultPointerKey;
+    } else if (typeof active === 'boolean') {
+      this.active = active ? this._defaultActive : EventType.NONE;
+    } else {
+      this.active = active;
+    }
+  }
+
+  /**
+   * Sets the modification key to listen to or the default modification key if none is provided.
+   */
+  setModification(mod?: ModificationKeyType): void {
+    if (mod) {
+      this.modificationKey = mod;
+    } else {
+      this.modificationKey = this._defaultModificationKey;
+    }
+  }
+
+  /**
+   * Sets the pointer key for this interaction or the default pointer if none is provided.
+   */
+  setPointer(pointer?: PointerKeyType): void {
+    if (pointer) {
+      this.pointerKey = pointer;
+    } else {
+      this.pointerKey = this._defaultPointerKey;
+    }
+  }
+
+  /**
+   * destroys the implementation, removing any created resources
+   */
+  // eslint-disable-next-line class-methods-use-this
+  destroy(): void {}
+}
+
+export default AbstractInteraction;