@vcmap/core 5.0.0-rc.8 → 5.0.0

package/src/featureProvider/wmsFeatureProvider.js

@@ -1,286 +0,0 @@
-import GML2 from 'ol/format/GML2.js';
-import WFS from 'ol/format/WFS.js';
-import GeoJSON 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 { parseInteger } from '@vcsuite/parsers';
-import AbstractFeatureProvider from './abstractFeatureProvider.js';
-import Projection, { mercatorProjection } from '../util/projection.js';
-import { getWMSSource } from '../layer/wmsHelpers.js';
-import Extent from '../util/extent.js';
-import { requestJson } from '../util/fetch.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
- */
-
-const gmlFormats = {
-  GML: GML3,
-  GML2,
-  GML3,
-};
-
-/**
- * @type {Array<string>}
- * @const
- */
-const geojsonFormats = [
-  'application/geojson',
-  'application/json',
-  'application/vnd.geo+json',
-];
-
-/**
- * @param {string} responseType
- * @param {Object} options
- * @returns {null|import("ol/format/Feature").default}
- */
-export function getFormat(responseType, options = {}) {
-  if (responseType === 'text/xml') {
-    options.gmlFormat = options.gmlFormat ? new gmlFormats[options.gmlFormat]() : new GML2();
-    return new WFS(options);
-  }
-  if (geojsonFormats.includes(responseType)) {
-    return new GeoJSON(options);
-  }
-  if (responseType === 'application/vnd.ogc.gml') {
-    return new GML2(options);
-  }
-  if (responseType === 'application/vnd.ogc.gml/3.1.1') {
-    return new GML3(options);
-  }
-  return null;
-}
-
-/**
- * @class
- * @export
- * @extends {AbstractFeatureProvider}
- */
-class WMSFeatureProvider extends AbstractFeatureProvider {
-  static get className() { return 'WMSFeatureProvider'; }
-
-  /**
-   * @returns {WMSFeatureProviderOptions}
-   */
-  static getDefaultOptions() {
-    return {
-      ...AbstractFeatureProvider.getDefaultOptions(),
-      responseType: 'text/xml',
-      style: undefined,
-      formatOptions: undefined,
-      projection: undefined,
-      url: '',
-      tilingSchema: 'geographic',
-      version: '1.1.1',
-      maxLevel: 0,
-      minLevel: 0,
-      tileSize: [256, 256],
-      parameters: {},
-      extent: undefined,
-    };
-  }
-
-  /**
-   * @param {string} layerName
-   * @param {WMSFeatureProviderOptions} options
-   */
-  constructor(layerName, options) {
-    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;
-      } else {
-        this.extent = new Extent(options.extent);
-      }
-    }
-    /** @type {WMSSourceOptions} */
-    this._wmsSourceOptions = {
-      url: options.url,
-      tilingSchema: options.tilingSchema || defaultOptions.tilingSchema,
-      maxLevel: parseInteger(options.maxLevel, defaultOptions.maxLevel),
-      minLevel: parseInteger(options.minLevel, defaultOptions.minLevel),
-      tileSize: options.tileSize || defaultOptions.tileSize,
-      parameters: options.parameters,
-      version: options.version || defaultOptions.version,
-    };
-    /**
-     * 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.featureInfoResponseType = options.responseType || defaultOptions.responseType;
-    /**
-     * @type {Object}
-     * @private
-     */
-    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;
-
-    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,
-      }));
-    } catch (ex) {
-      this.getLogger().warning('Features could not be read, please verify the featureInfoResponseType with the capabilities from the server');
-      return [];
-    }
-
-    if (Array.isArray(features)) {
-      features.forEach((feature) => {
-        const geometry = feature.getGeometry();
-        if (!geometry) {
-          feature.setGeometry(new Point(coordinate));
-        }
-      });
-      return features;
-    }
-
-    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();
-    let coords = coordinate;
-    if (projection) {
-      const transform = getTransform(mercatorProjection.proj, projection);
-      // error in TransformFunction type definition, remove undefined after openlayer fixed the type
-      coords = transform(coordinate.slice(), undefined, undefined);
-    }
-
-    const metersPerUnit = 111194.87428468118;
-    const url = this.wmsSource.getFeatureInfoUrl(
-      coords,
-      resolution / metersPerUnit,
-      projection,
-      { INFO_FORMAT: this.featureInfoResponseType },
-    );
-
-    if (url) {
-      let data;
-      try {
-        data = await requestJson(url);
-      } catch (ex) {
-        this.getLogger().error(`Failed fetching WMS FeatureInfo ${url}`);
-        return [];
-      }
-      return this.featureResponseCallback(data, coordinate)
-        .map(f => this.getProviderFeature(f));
-    }
-    return [];
-  }
-
-  /**
-   * @inheritDoc
-   * @returns {WMSFeatureProviderOptions}
-   */
-  toJSON() {
-    const config = /** @type {WMSFeatureProviderOptions} */ (super.toJSON());
-    const defaultOptions = WMSFeatureProvider.getDefaultOptions();
-    if (this.featureInfoResponseType !== defaultOptions.responseType) {
-      config.responseType = this.featureInfoResponseType;
-    }
-
-    if (this._formatOptions !== defaultOptions.formatOptions) {
-      config.formatOptions = { ...this._formatOptions };
-    }
-
-    if (this.projection !== defaultOptions.projection) {
-      config.projection = this.projection.toJSON();
-    }
-
-    config.url = this._wmsSourceOptions.url;
-    config.parameters = { ...this._wmsSourceOptions.parameters };
-
-    if (this._wmsSourceOptions.tilingSchema !== defaultOptions.tilingSchema) {
-      config.tilingSchema = this._wmsSourceOptions.tilingSchema;
-    }
-    if (this._wmsSourceOptions.maxLevel !== defaultOptions.maxLevel) {
-      config.maxLevel = this._wmsSourceOptions.maxLevel;
-    }
-    if (this._wmsSourceOptions.minLevel !== defaultOptions.minLevel) {
-      config.minLevel = this._wmsSourceOptions.minLevel;
-    }
-    if (this._wmsSourceOptions.version !== defaultOptions.version) {
-      config.version = this._wmsSourceOptions.version;
-    }
-    if (
-      this._wmsSourceOptions.tileSize[0] !== defaultOptions.tileSize[0] ||
-      this._wmsSourceOptions.tileSize[1] !== defaultOptions.tileSize[1]
-    ) {
-      config.tileSize = this._wmsSourceOptions.tileSize.slice();
-    }
-    if (this.extent) {
-      config.extent = this.extent.toJSON();
-    }
-
-    return config;
-  }
-
-  /**
-   * @inheritDoc
-   */
-  destroy() {
-    this.wmsSource = undefined;
-    this.featureFormat = undefined;
-    this.projection = undefined;
-    this._formatOptions = undefined;
-    super.destroy();
-  }
-}
-
-export default WMSFeatureProvider;

package/src/globalCollections.js

@@ -1,7 +0,0 @@
-import Collection from './util/collection.js';
-
-/**
- * @type {import("@vcmap/core").Collection<import("@vcmap/core").StyleItem>}
- */
-// eslint-disable-next-line import/prefer-default-export
-export const styleCollection = new Collection();

package/src/interaction/abstractInteraction.js

@@ -1,151 +0,0 @@
-import { v4 as uuidv4 } from 'uuid';
-import { EventType, ModificationKeyType, PointerKeyType } from './interactionType.js';
-
-/**
- * @typedef {Object} ObliqueParameters
- * @property {import("ol/coordinate").Coordinate} pixel - the image pixel clicked
- * @property {boolean|undefined} estimate - true if the terrain could not be taken into account
- * @api
- */
-
-/**
- * @typedef {MapEvent} InteractionEvent
- * @property {EventType} type
- * @property {undefined|import("ol").Feature<import("ol/geom/Geometry").default>|import("@vcmap/cesium").Cesium3DTileFeature|import("@vcmap/cesium").Cesium3DTilePointFeature} feature - a potential feature at said location
- * @property {boolean|undefined} stopPropagation - if set to true, the event chain is interrupted
- * @property {undefined|ObliqueParameters} obliqueParameters - additional parameters from oblique if obliquemode is active
- * @property {import("@vcmap/cesium").Ray|undefined} ray - potential ray
- * @property {boolean|undefined} exactPosition - whether the position is exact, eg with translucentDepthPicking on
- * @api
- */
-
-/**
- * An abstract interface for all interactions
- * @class
- * @export
- * @abstract
- * @api
- */
-class AbstractInteraction {
-  /**
-   * @param {number} [defaultActive=EventType.NONE] - A bitmask representing the default {@link EventType} to listen to
-   * @param {number} [defaultModificationKey=ModificationKeyType.NONE] - A bitmask representing the default {@link ModificationKeyType} keys to listen to
-   * @param {number} [defaultPointerKey=PointerKeyType.LEFT] - A bitmask representing the {@link PointerKeyType} pointer key to listen to
-   */
-  constructor(
-    defaultActive = EventType.NONE,
-    defaultModificationKey = ModificationKeyType.NONE,
-    defaultPointerKey = PointerKeyType.LEFT,
-  ) {
-    /**
-     * A unique identifier for this interaction
-     * @type {string}
-     * @api
-     */
-    this.id = uuidv4();
-
-    /**
-     * @type {number}
-     * @private
-     */
-    this._defaultActive = defaultActive;
-
-    /**
-     * The current active bitmask for {@link EventType}
-     * @type {number}
-     * @api
-     */
-    this.active = this._defaultActive;
-
-    /**
-     * @type {number}
-     * @private
-     */
-    this._defaultModificationKey = defaultModificationKey;
-
-    /**
-     * The current active {@link ModificationKeyType}
-     * @type {number}
-     * @api
-     */
-    this.modificationKey = this._defaultModificationKey;
-
-    /**
-     * @type {number}
-     * @private
-     */
-    this._defaultPointerKey = defaultPointerKey;
-
-    /**
-     * The currently active {@link PointerKeyType}
-     * @type {number}
-     */
-    this.pointerKey = this._defaultPointerKey;
-  }
-
-  /**
-   * Main function, called when an event is raised for this interaction
-   * @param {InteractionEvent} event
-   * @returns {Promise<InteractionEvent>}
-   * @api
-   */
-  // eslint-disable-next-line class-methods-use-this
-  async pipe(event) {
-    return event;
-  }
-
-  /**
-   * 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
-   * @param {(boolean|number)=} active
-   * @api
-   */
-  setActive(active) {
-    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.
-   * @param {number=} mod
-   * @api
-   */
-  setModification(mod) {
-    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.
-   * @param {number=} pointer
-   * @api
-   */
-  setPointer(pointer) {
-    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() {}
-}
-
-export default AbstractInteraction;

package/src/interaction/coordinateAtPixel.js

@@ -1,99 +0,0 @@
-import { Cartographic, Cartesian3, Math as CesiumMath } from '@vcmap/cesium';
-import AbstractInteraction from './abstractInteraction.js';
-import Projection, { mercatorProjection } from '../util/projection.js';
-import { EventType, ModificationKeyType } from './interactionType.js';
-import { transformFromImage } from '../oblique/helpers.js';
-
-/**
- * @class
- * @extends {AbstractInteraction}
- */
-class CoordinateAtPixel extends AbstractInteraction {
-  constructor() {
-    super(EventType.ALL, ModificationKeyType.ALL);
-    /**
-     * @type {import("@vcmap/cesium").Cartographic}
-     * @private
-     */
-    this._scratchCartographic = new Cartographic();
-    /**
-     * @type {import("@vcmap/cesium").Cartesian3}
-     * @private
-     */
-    this._scratchCartesian = new Cartesian3();
-
-    this.setActive();
-  }
-
-  /**
-   * @inheritDoc
-   * @param {InteractionEvent} event
-   * @returns {Promise<InteractionEvent>}
-   */
-  // eslint-disable-next-line class-methods-use-this
-  async pipe(event) {
-    if (event.map.className === 'CesiumMap') {
-      return this._cesiumHandler(event);
-    } else if (event.map.className === 'ObliqueMap') {
-      return CoordinateAtPixel.obliqueHandler(event);
-    }
-    return event;
-  }
-
-  /**
-   * @param {InteractionEvent} event
-   * @returns {Promise<InteractionEvent>}
-   * @private
-   */
-  _cesiumHandler(event) {
-    const cesiumMap = /** @type {import("@vcmap/core").CesiumMap} */ (event.map);
-    const scene = cesiumMap.getScene();
-    event.ray = scene.camera.getPickRay(event.windowPosition);
-    const pickResult = scene.globe.pick(event.ray, scene, this._scratchCartesian);
-    if (!pickResult) {
-      event.position = [0, 0, 0];
-    } else {
-      this._scratchCartographic = Cartographic
-        .fromCartesian(pickResult, scene.globe.ellipsoid, this._scratchCartographic);
-      event.position = Projection.wgs84ToMercator([
-        CesiumMath.toDegrees(this._scratchCartographic.longitude),
-        CesiumMath.toDegrees(this._scratchCartographic.latitude),
-        this._scratchCartographic.height,
-      ], true);
-    }
-    event.positionOrPixel = event.position;
-    return Promise.resolve(event);
-  }
-
-  /**
-   * @param {InteractionEvent} event
-   * @returns {Promise<InteractionEvent>}
-   * @private
-   */
-  static obliqueHandler(event) {
-    const obliqueMap = /** @type {import("@vcmap/core").ObliqueMap} */ (event.map);
-    const image = obliqueMap.currentImage;
-    if (image) {
-      // don't use TerrainLayer for coordinate Transformation if the event is a move or drag event,
-      // to avoid requesting the terrain each mousemove...
-      // XXX but what about DRAGSTART and DRAGEND? this could be usefull, no?
-      const move = event.type & (EventType.MOVE ^ EventType.DRAGEVENTS);
-      const pixel = event.position.slice(0, 2);
-      if (Number.isFinite(pixel[0]) && Number.isFinite(pixel[1])) {
-        return transformFromImage(image, pixel, {
-          dontUseTerrain: !!move,
-          dataProjection: mercatorProjection,
-        }).then((coordinates) => {
-          event.obliqueParameters = { pixel };
-          event.position = coordinates.coords;
-          event.obliqueParameters.estimate = coordinates.estimate;
-          return event;
-        });
-      }
-    }
-    event.stopPropagation = true;
-    return Promise.resolve(event);
-  }
-}
-
-export default CoordinateAtPixel;