@vcmap/core 5.0.0-rc.8 → 5.0.0

package/src/category/categoryCollection.js

@@ -1,145 +0,0 @@
-import { getLogger as getLoggerByName } from '@vcsuite/logger';
-import Category from './category.js';
-import { getObjectFromOptions } from '../vcsAppContextHelpers.js';
-import './appBackedCategory.js';
-import IndexedCollection from '../util/indexedCollection.js';
-
-/**
- * @returns {import("@vcsuite/logger").Logger}
- */
-function getLogger() {
-  return getLoggerByName('CategoryCollection');
-}
-
-/**
- * @class
- * @extends {IndexedCollection<Category<Object|import("@vcmap/core").VcsObject>>}
- */
-class CategoryCollection extends IndexedCollection {
-  /**
-   * @param {import("@vcmap/core").VcsApp} app
-   */
-  constructor(app) {
-    super();
-    /**
-     * @type {import("@vcmap/core").VcsApp}
-     * @private
-     */
-    this._app = app;
-    /**
-     * Map of category names, where the value is a map of contextId and items.
-     * @type {Map<string, Map<string, Array<Object>>>}
-     * @private
-     */
-    this._cache = new Map();
-    /**
-     * @type {Function}
-     * @private
-     */
-    this._contextRemovedListener = this._app.contextRemoved.addEventListener((context) => {
-      this._cache.forEach((contextMap, name) => {
-        contextMap.delete(context.id);
-        if (contextMap.size === 0) {
-          this._cache.delete(name);
-        }
-      });
-    });
-  }
-
-  /**
-   * Do not call add directly. Use request category for adding categories.
-   * @param {Category<Object|import("@vcmap/core").VcsObject>} category
-   * @returns {number|null}
-   */
-  add(category) { // XXX use a symbol to enforce using request over add?
-    if (this.hasKey(category.name)) {
-      return null;
-    }
-
-    category.setApp(this._app);
-    const added = super.add(category);
-    if (added != null && this._cache.has(category.name)) {
-      this._cache
-        .get(category.name)
-        .forEach((items, contextId) => {
-          this.parseCategoryItems(category.name, items, contextId);
-        });
-
-      this._cache.delete(category.name);
-    }
-    return added;
-  }
-
-  /**
-   * Categories should be static. Removing them can lead to undefined behavior.
-   * @param {Category<Object|import("@vcmap/core").VcsObject>} category
-   */
-  remove(category) { // XXX add logger warning?
-    super.remove(category);
-    this._cache.delete(category.name);
-  }
-
-  /**
-   * Parses the category items. Items will only be parsed, if a category with said name exists. Otherwise,
-   * they will be cached, until such a category is requested.
-   * @param {string} name
-   * @param {Array<Object>} items
-   * @param {string} contextId
-   * @returns {Promise<void>}
-   */
-  async parseCategoryItems(name, items, contextId) {
-    const category = this.getByKey(name);
-
-    if (category) {
-      await category.collection.parseItems(items, contextId);
-    } else if (this._cache.has(name)) {
-      this._cache.get(name).set(contextId, items);
-    } else {
-      this._cache.set(name, new Map([[contextId, items]]));
-    }
-  }
-
-  /**
-   * Add categories with this API.
-   * @param {CategoryOptions} options
-   * @returns {Promise<Category<Object|import("@vcmap/core").VcsObject>>}
-   */
-  async requestCategory(options) {
-    if (!options.name) {
-      getLogger().error('Cannot request a category without a name');
-      return null;
-    }
-
-    if (!options.type) {
-      getLogger().warning(`Implicitly typing category ${options.name} as ${Category.className}`);
-      options.type = Category.className;
-    }
-
-    let category;
-    if (this.hasKey(options.name)) {
-      category = this.getByKey(options.name);
-      category.mergeOptions(options);
-    } else {
-      category = await getObjectFromOptions(options);
-      if (category) {
-        if (this.add(category) == null) {
-          return null;
-        }
-      }
-    }
-
-    if (!category) {
-      throw new Error(`Category ${options.name} with type ${category.type} could not be created`);
-    }
-    return category;
-  }
-
-  destroy() {
-    super.destroy();
-    this._contextRemovedListener();
-    this._cache.clear();
-    this._app = null;
-  }
-}
-
-export default CategoryCollection;

package/src/cesium/cesium3DTileFeature.js

@@ -1,9 +0,0 @@
-// @ts-nocheck
-import { Cesium3DTileFeature } from '@vcmap/cesium';
-
-/**
- * @returns {string|number}
- */
-Cesium3DTileFeature.prototype.getId = function getId() {
-  return this.getProperty('id') || `${this.content.url}${this._batchId}`;
-};

package/src/cesium/cesium3DTilePointFeature.js

@@ -1,9 +0,0 @@
-// @ts-nocheck
-import { Cesium3DTilePointFeature } from '@vcmap/cesium';
-
-/**
- * @returns {string|number}
- */
-Cesium3DTilePointFeature.prototype.getId = function getId() {
-  return this.getProperty('id') || `${this.content.url}${this._batchId}`;
-};

package/src/classRegistry.js

@@ -1,89 +0,0 @@
-import { check } from '@vcsuite/check';
-import { getLogger } from '@vcsuite/logger';
-
-/**
- * @class
- * @api
- */
-class ClassRegistry {
-  constructor() {
-    /**
-     * @type {Map<string, function():(function(new: *, ...*)|Promise<function(new: *, ...*)>)>}
-     * @private
-     */
-    this._classMap = new Map();
-    /**
-     * @type {import("@vcsuite/logger").Logger}
-     */
-    this.logger = getLogger('ClassRegistry');
-  }
-
-  /**
-   * Register a class by its class name.
-   * @param {string} className
-   * @param {function(new: *, ...*)} ctor
-   * @api
-   */
-  registerClass(className, ctor) {
-    check(className, String);
-    check(ctor, Function);
-
-    if (this._classMap.has(className)) {
-      throw new Error('a constructor with this className has already been registered');
-    }
-
-    this._classMap.set(className, () => ctor);
-  }
-
-  /**
-   * @param {string} className
-   * @param {function():Promise<function(new: *, ...*)>} cb - a callback providing a promise which returns the constructor on resolve.
-   * used for lazy loading modules, e.g
-   * <code>ClassRegistry.registerDeferredClass(() => import('my-module').then(({ default: MyCtor }) => MyCtor));</code>
-   * @api
-   */
-  registerDeferredClass(className, cb) {
-    check(className, String);
-    check(cb, Function);
-
-    this._classMap.set(className, cb);
-  }
-
-  /**
-   * Gets the constructor for a registered class or undefined, if no such class was registerd
-   * @param {string} className
-   * @returns {function(new: *, ...*)|Promise<*>|undefined}
-   * @api
-   */
-  getClass(className) {
-    if (this._classMap.has(className)) {
-      return this._classMap.get(className)();
-    }
-    return undefined;
-  }
-
-  /**
-   * @param {string} className
-   * @param {...*} args
-   * @returns {Promise<*>}
-   * @api
-   */
-  async create(className, ...args) {
-    check(className, String);
-
-    const Ctor = await this.getClass(className);
-    if (!Ctor) {
-      this.logger.error(`could not find constructor ${className}`);
-      return undefined;
-    }
-    return new Ctor(...args);
-  }
-}
-
-export default ClassRegistry;
-
-/**
- * @export
- * @type {ClassRegistry}
- */
-export const VcsClassRegistry = new ClassRegistry();

package/src/context.js

@@ -1,73 +0,0 @@
-import { v4 as uuidv4, v5 as uuidv5 } from 'uuid';
-
-/**
- * @typedef {Object} VcsAppConfig
- * @property {string|undefined} [id]
- * @property {Array<LayerOptions>} [layers]
- * @property {Array<VcsMapOptions>} [maps]
- * @property {Array<StyleItemOptions>} [styles]
- * @property {Array<ViewPointOptions>} [viewpoints]
- * @property {string} [startingViewPointName]
- * @property {string} [startingMapName]
- * @property {ProjectionOptions} [projection]
- * @property {Array<{ name: string, items: Array<Object> }>} [categories]
- * @property {Array<ObliqueCollectionOptions>} [obliqueCollections]
- */
-
-/**
- * @type {string}
- */
-const uuidNamespace = uuidv4();
-
-/**
- * @class
- * @export
- */
-class Context {
-  /**
-   * @param {VcsAppConfig} config
-   */
-  constructor(config) {
-    /**
-     * @type {VcsAppConfig}
-     * @private
-     */
-    this._config = config;
-    /**
-     * @type {string}
-     * @private
-     */
-    this._checkSum = uuidv5(JSON.stringify(config), uuidNamespace);
-    /**
-     * @type {string}
-     * @private
-     */
-    this._id = config.id || this._checkSum;
-  }
-
-  /**
-   * @type {string}
-   * @readonly
-   */
-  get id() {
-    return this._id;
-  }
-
-  /**
-   * @type {string}
-   * @readonly
-   */
-  get checkSum() {
-    return this._checkSum;
-  }
-
-  /**
-   * @type {VcsAppConfig}
-   * @readonly
-   */
-  get config() {
-    return JSON.parse(JSON.stringify(this._config));
-  }
-}
-
-export default Context;

package/src/featureProvider/abstractFeatureProvider.js

@@ -1,196 +0,0 @@
-import { v4 as uuidv4 } from 'uuid';
-import { parseBoolean } from '@vcsuite/parsers';
-import { vcsLayerName } from '../layer/layerSymbols.js';
-import VcsObject from '../vcsObject.js';
-import { getStyleOrDefaultStyle } from '../style/styleFactory.js';
-import { defaultVectorStyle } from '../style/vectorStyleItem.js';
-import VectorProperties from '../layer/vectorProperties.js';
-import { isProvidedFeature, showProvidedFeature } from './featureProviderSymbols.js';
-
-/**
- * @namespace featureProvider
- */
-
-/**
- * @typedef {VcsObjectOptions} AbstractFeatureProviderOptions
- * @property {import("@vcmap/core").StyleItemOptions|import("@vcmap/core").StyleItem|undefined} style - the style to apply to features created by this feature provider
- * @property {Object|undefined} genericFeatureProperties - generic properties to add to features created by this feature provider
- * @property {import("@vcmap/core").VectorProperties|import("@vcmap/core").VectorPropertiesOptions|undefined} vectorProperties - the vector properties of the features. Allow picking is false by default.
- * @property {boolean} [showGeometry=false] - show the resulting geometry in the map
- * @property {Array<string>} [mapTypes=[]] - can be used to constrict the featureProvider to specific mapTypes empty array means no restriction
- */
-
-/**
- * An abstract class providing features for {@link Layer}s which cannot provide features directly, but can provide features for
- * a given location, e.g. WmsLayer with a getFeatureInfo configuration. In this case, a feature provider can be created for this layer.
- * @class
- * @export
- * @abstract
- * @api
- */
-class AbstractFeatureProvider extends VcsObject {
-  static get className() { return 'AbstractFeatureProvider'; }
-
-  /**
-   * @returns {AbstractFeatureProviderOptions}
-   */
-  static getDefaultOptions() {
-    return {
-      vectorProperties: {
-        allowPicking: false,
-      },
-      genericFeatureProperties: undefined,
-      showGeometry: false,
-      mapTypes: [],
-    };
-  }
-
-  /**
-   * @param {string} layerName
-   * @param {AbstractFeatureProviderOptions} options
-   */
-  constructor(layerName, options) {
-    super(options);
-    const defaultOptions = AbstractFeatureProvider.getDefaultOptions();
-    /**
-     * The layer name of the associated layer
-     * @api
-     * @type {string}
-     */
-    this.layerName = layerName;
-    /**
-     * The style set on features created by this provider
-     * @type {import("@vcmap/core").StyleItem|undefined}
-     * @api
-     */
-    this.style = options.style ?
-      getStyleOrDefaultStyle(options.style, defaultVectorStyle.clone()) :
-      undefined;
-    /**
-     * Whether to show the geometry on selection.
-     * @type {boolean}
-     * @api
-     */
-    this.showGeometry = parseBoolean(options.showGeometry, defaultOptions.showGeometry);
-    /**
-     * The vector properties assigned to features created by this provider
-     * @type {import("@vcmap/core").VectorProperties}
-     * @api
-     */
-    this.vectorProperties = options.vectorProperties instanceof VectorProperties ?
-      options.vectorProperties :
-      new VectorProperties({ ...defaultOptions.vectorProperties, ...options.vectorProperties });
-    /**
-     * An object of potential generic feature properties to add to all feature created by this provider
-     * @type {Object<string, *>|undefined}
-     * @api
-     */
-    this.genericFeatureProperties = options.genericFeatureProperties || defaultOptions.genericFeatureProperties;
-
-    /**
-     * Map ClassNames Can be used to only apply this featureProvider to the specified maps
-     * @type {Array<string>}
-     * @api
-     */
-    this.mapTypes = Array.isArray(options.mapTypes) ? options.mapTypes : defaultOptions.mapTypes;
-  }
-
-  /**
-   * checks if the featureProvider is supported for provided Map
-   * @param {import("@vcmap/core").VcsMap} map
-   * @returns {boolean}
-   * @api stable
-   */
-  isSupported(map) {
-    return map &&
-      (this.mapTypes.length === 0 || this.mapTypes.includes(map.className));
-  }
-
-  /**
-   * Ensures the feature has an ID, applies all vectorProperties and adds the generic properties, style and the vcsLayerName
-   * and isProvidedFeature symbols to the feature
-   * @param {import("ol").Feature<import("ol/geom/Geometry").default>} feature
-   * @returns {import("ol").Feature<import("ol/geom/Geometry").default>}
-   * @api
-   */
-  getProviderFeature(feature) {
-    if (!feature.getId()) {
-      feature.setId(uuidv4());
-    }
-    if (this.style) {
-      feature.setStyle(this.style.style);
-    }
-    if (this.genericFeatureProperties) {
-      feature.setProperties(this.genericFeatureProperties);
-    }
-    feature[vcsLayerName] = this.layerName;
-    feature[isProvidedFeature] = true;
-    feature[showProvidedFeature] = this.showGeometry;
-    Object.entries(this.vectorProperties.getValues()).forEach(([key, value]) => {
-      const olcsKey = `olcs_${key}`;
-      if (feature.get(olcsKey) === undefined && value !== undefined) {
-        feature.set(olcsKey, value);
-      }
-    });
-    return feature;
-  }
-
-  /**
-   * This method must be overwritten by any implementations. Before returning the array of features, be sure to use the getProviderFeature
-   * on each feature to ensure all properties and symbols required by the VCM architecture
-   * to handle your feature is called: (e.g. <code>return features.map(f => this.getProviderFeature(f)</code>);
-   * @param {import("ol/coordinate").Coordinate} coordinate - in mercator
-   * @param {number} resolution - meters per pixel for the given location
-   * @returns {Promise<Array<import("ol").Feature<import("ol/geom/Geometry").default>>>}
-   * @api
-   */
-  // eslint-disable-next-line no-unused-vars,class-methods-use-this
-  async getFeaturesByCoordinate(coordinate, resolution) {
-    return [];
-  }
-
-  /**
-   * Returns the object required to configure this feature provider.
-   * @returns {AbstractFeatureProviderOptions}
-   * @api
-   */
-  toJSON() {
-    const config =
-      /** @type {AbstractFeatureProviderOptions} */ (super.toJSON());
-
-    const defaultOptions = AbstractFeatureProvider.getDefaultOptions();
-    delete config.name; // the name is irrelevant, since its the layers name
-
-    if (this.showGeometry !== defaultOptions.showGeometry) {
-      config.showGeometry = this.showGeometry;
-    }
-
-    if (this.genericFeatureProperties) {
-      config.genericFeatureProperties = { ...this.genericFeatureProperties };
-    }
-
-    if (this.style) {
-      config.style = this.style.getOptions();
-    }
-
-    const vectorPropertiesConfig = this.vectorProperties
-      .getVcsMeta({ ...VectorProperties.getDefaultOptions(), ...defaultOptions.vectorProperties });
-    if (Object.keys(vectorPropertiesConfig).length > 0) {
-      config.vectorProperties = vectorPropertiesConfig;
-    }
-    return config;
-  }
-
-  /**
-   * Destroys this feature provider and detaches its resources
-   * @inheritDoc
-   */
-  destroy() {
-    this.style = null;
-    this.vectorProperties.destroy();
-    this.genericFeatureProperties = undefined;
-    super.destroy();
-  }
-}
-
-export default AbstractFeatureProvider;

package/src/featureProvider/featureProviderHelpers.js

@@ -1,50 +0,0 @@
-import { getCenter } from 'ol/extent.js';
-import Projection from '../util/projection.js';
-import Extent3D from '../util/featureconverter/extent3D.js';
-
-/**
- * @param {VectorClickedObject} feature
- * @param {import("@vcmap/core").Layer} layer
- * @returns {?GenericFeature}
- */
-// eslint-disable-next-line import/prefer-default-export
-export function getGenericFeatureFromProvidedFeature(feature, layer) {
-  const attributes = feature.getProperties();
-  delete attributes[feature.getGeometryName()];
-
-  let { clickedPosition } = feature;
-  const geometry = feature.getGeometry();
-  const isModel = feature.get('olcs_modelUrl');
-  if (
-    geometry &&
-    (
-      (geometry.getType() === 'Point' && !isModel) ||
-      (clickedPosition && !clickedPosition.exactPosition) ||
-      (!clickedPosition && geometry)
-    )
-  ) {
-    const center = getCenter(geometry.getExtent());
-    if (center) {
-      Projection.mercatorToWgs84(center, true);
-      clickedPosition = { longitude: center[0], latitude: center[1] };
-    }
-  }
-
-  let heightOffset = clickedPosition.height;
-  if (!isModel) {
-    const extent = Extent3D.fromGeometry(geometry);
-    heightOffset = Number.isFinite(extent.maxZ) ? extent.maxZ : 0;
-  }
-  const relativeToGround = !isModel && feature.get('olcs_altitudeMode') === 'relativeToGround';
-
-  delete attributes.clickedPosition;
-  return {
-    layerName: layer.name,
-    layerClass: layer.className,
-    attributes,
-    longitude: clickedPosition.longitude,
-    latitude: clickedPosition.latitude,
-    height: heightOffset,
-    relativeToGround,
-  };
-}

package/src/featureProvider/featureProviderSymbols.js

@@ -1,11 +0,0 @@
-/**
- * Added to ol.Feature, if they are not part of a layer, but provided by an {@link AbstractFeatureProvider}.
- * @type {symbol}
- */
-export const isProvidedFeature = Symbol('isProvidedFeature');
-
-/**
- * A boolean value, indicating whether {@link SelectBehavior} should add the feature to the selected item layer
- * @type {symbol}
- */
-export const showProvidedFeature = Symbol('showProvidedFeature');

package/src/featureProvider/tileProviderFeatureProvider.js

@@ -1,62 +0,0 @@
-import AbstractFeatureProvider from './abstractFeatureProvider.js';
-
-
-/**
- * @typedef {AbstractFeatureProviderOptions} TileProviderFeatureProviderOptions
- * @property {import("@vcmap/core").TileProvider} tileProvider
- * @api
- */
-
-/**
- * @class
- * @extends {AbstractFeatureProvider}
- */
-class TileProviderFeatureProvider extends AbstractFeatureProvider {
-  static get className() { return 'TileProviderFeatureProvider'; }
-
-  /**
-   * @param {string} layerName
-   * @param {TileProviderFeatureProviderOptions} options
-   */
-  constructor(layerName, options) {
-    super(layerName, options);
-
-    /**
-     * Map ClassNames Can be used to only apply this featureProvider to the specified maps
-     * @type {Array<string>}
-     * @api
-     */
-    this.mapTypes = ['CesiumMap'];
-
-    /**
-     * TileProvider
-     * @type {import("@vcmap/core").TileProvider}
-     * @api
-     */
-    this.tileProvider = options.tileProvider;
-  }
-
-
-  /**
-   * @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 features = await this.tileProvider.getFeaturesByCoordinate(coordinate, resolution);
-    return features.filter((feature) => {
-      return this.vectorProperties.getAllowPicking(feature);
-    });
-  }
-
-  /**
-   * @inheritDoc
-   */
-  destroy() {
-    this.tileProvider = undefined;
-    super.destroy();
-  }
-}
-
-export default TileProviderFeatureProvider;