@vcmap/core 5.0.0-rc.8 → 5.0.0

package/src/util/math.js

@@ -1,71 +0,0 @@
-import { Math as CesiumMath, Cartesian3 } from '@vcmap/cesium';
-
-/**
- * returns a new coordinate ([lon, lat] in degrees) from a distance, bearing and starting coordinate
- * @param {Array.<number>} coord [lon, lat] in degrees
- * @param {number} d distance in m to new coordinate
- * @param {number} brng bearing in degrees ( 0 == north, 90° == east)
- * @returns {Array.<number>};
- */
-export function coordinateAtDistance(coord, d, brng) {
-  const R = 6371000;
-  const brngRadians = CesiumMath.toRadians(brng);
-  const lat1 = CesiumMath.toRadians(coord[1]);
-  const lon1 = CesiumMath.toRadians(coord[0]);
-  const lat2 = Math.asin((Math.sin(lat1) * Math.cos(d / R)) +
-    (Math.cos(lat1) * Math.sin(d / R) * Math.cos(brngRadians)));
-  const lon2 = lon1 + Math.atan2(
-    Math.sin(brngRadians) * Math.sin(d / R) * Math.cos(lat1),
-    Math.cos(d / R) - (Math.sin(lat1) * Math.sin(lat2)),
-  );
-  return [parseFloat(CesiumMath.toDegrees(lon2).toFixed(5)), parseFloat(CesiumMath.toDegrees(lat2).toFixed(5))];
-}
-
-
-/**
- * returns the initial bearing in degrees (0-360) between two coordinates
- * @param {Array.<number>} coords1 [lon, lat] in degrees
- * @param {Array.<number>} coords2 [lon, lat] in degrees
- * @returns {number};
- */
-export function initialBearingBetweenCoords(coords1, coords2) {
-  // long
-  const l1 = CesiumMath.toRadians(coords1[0]);
-  // lat
-  const f1 = CesiumMath.toRadians(coords1[1]);
-  // long
-  const l2 = CesiumMath.toRadians(coords2[0]);
-  // lat
-  const f2 = CesiumMath.toRadians(coords2[1]);
-
-  const y = Math.sin(l2 - l1) * Math.cos(f2);
-  const x = (Math.cos(f1) * Math.sin(f2)) - (Math.sin(f1) * Math.cos(f2) * Math.cos(l2 - l1));
-  let brng = CesiumMath.toDegrees(Math.atan2(y, x));
-  brng = (brng + 360) % 360;
-  return brng;
-}
-
-
-/**
- * returns distance between two coordinates
- * @param {import("ol/coordinate").Coordinate} point0
- * @param {import("ol/coordinate").Coordinate} point1
- * @returns {number}
- */
-export function cartesian2DDistance(point0, point1) {
-  const distX = point0[0] - point1[0];
-  const distY = point0[1] - point1[1];
-  return Math.sqrt((distX ** 2) + (distY ** 2));
-}
-
-/**
- * @param {import("ol/coordinate").Coordinate} p1
- * @param {import("ol/coordinate").Coordinate} p2
- * @returns {number}
- */
-export function cartesian3DDistance(p1, p2) {
-  const point0 = Cartesian3.fromElements(p1[0], p1[1], p1[2]);
-  const point1 = Cartesian3.fromElements(p2[0], p2[1], p2[2]);
-  return Cartesian3.distance(point0, point1);
-}
-

package/src/util/overrideCollection.js

@@ -1,224 +0,0 @@
-/* eslint no-underscore-dangle: ["error", { "allow": ["_array"] }] */
-// eslint-disable-next-line max-classes-per-file
-import { check } from '@vcsuite/check';
-import { getLogger as getLoggerByName } from '@vcsuite/logger';
-import { contextIdSymbol } from '../vcsAppContextHelpers.js';
-import Collection from './collection.js';
-import VcsEvent from '../vcsEvent.js';
-
-/**
- * @returns {import("@vcsuite/logger").Logger}
- */
-function getLogger() {
-  return getLoggerByName('OverrideCollection');
-}
-
-/**
- * The override collection adds the ability to override a unique item and re-creating it, should the override
- * be removed. This does change some flow of called events. 1) if you override an item, removed is not called for the
- * removed current item. 2) added can be called more the once for the same unique id. 3) replaced is called for items
- * which where replaced. replaced is called after added has been called for the item.
- * @interface OverrideCollectionInterface
- * @property {import("@vcmap/core").VcsEvent<T>} replaced - replaced is called after added
- * @property {function(T):T|null} override - returns the overriden item or null if the item could not be inserted (this would be the result of a race condition)
- * @property {Map<string, Array<Object>>} shadowMap
- * @property {function(Array<Object>, string):Promise<void>} parseItems
- * @property {function(string):Promise<void>} removeContext
- * @property {function(string):Array<Object>} serializeContext
- * @template {*} T
- */
-
-/**
- * A symbol added to override collections.
- * @type {symbol}
- */
-export const isOverrideCollection = Symbol('OverrideCollection');
-
-/**
- * @param {Collection<T>} collection
- * @param {function():string} getDynamicContextId - function to get the current dynamic context id
- * @param {(function(T):Object)=} serializeItem - optional function to serialize an item, defaults to returning item.toJSON or item: i => (i.toJSON || i)
- * @param {(function(Object):(T|Promise<T>))=} deserializeItem - optional desirialization function. defaults to returning the passed object: i => i
- * @param {*=} ctor - optional constructor to validate deserialized items against. if passed, deserializeItem must be an instance of ctor.
- * @param {(function(T, (T|null|undefined), (number|undefined)):number|null)=} determineShadowIndex - return the index where a shadow should be inserted. only has relevance, if the collection is indexed. previous and current index may be null.
- * @template {*} T
- * @returns {OverrideCollection<T>}
- */
-function makeOverrideCollection(
-  collection,
-  getDynamicContextId,
-  serializeItem,
-  deserializeItem,
-  ctor,
-  determineShadowIndex,
-) {
-  check(collection, Collection);
-
-  const overrideCollection = /** @type {OverrideCollection<T>} */ (collection);
-  if (overrideCollection[isOverrideCollection]) {
-    throw new Error('Cannot transform collection, collection already is an OverrideCollection');
-  }
-  overrideCollection[isOverrideCollection] = true;
-
-  const deserialize = deserializeItem || (i => i);
-  // @ts-ignore
-  const serialize = serializeItem || (i => (i.toJSON ? i.toJSON() : i));
-  const getShadowIndex = determineShadowIndex || ((item, shadow, currentIndex) => currentIndex);
-
-  /**
-   * @type {Map<string, Array<Object>>}
-   */
-  overrideCollection.shadowMap = new Map();
-
-  /**
-   * @param {T} item
-   * @returns {T|null}
-   */
-  overrideCollection.override = function override(item) {
-    let shadow;
-    let index;
-    const itemId = item[overrideCollection.uniqueKey];
-
-    if (overrideCollection.hasKey(itemId)) {
-      shadow = overrideCollection.getByKey(itemId);
-      // @ts-ignore
-      index = overrideCollection._array.indexOf(shadow); // faking remove to not call removed
-      if (index > -1) {
-        // @ts-ignore
-        overrideCollection._array.splice(index, 1);
-      }
-      if (!overrideCollection.shadowMap.has(itemId)) {
-        overrideCollection.shadowMap.set(itemId, []);
-      }
-      const shadowsArray = overrideCollection.shadowMap.get(itemId);
-      const serializedShadow = serialize(shadow);
-      // @ts-ignore
-      if (shadow.destroy) {
-        // @ts-ignore
-        shadow.destroy();
-      }
-      serializedShadow[contextIdSymbol] = shadow[contextIdSymbol];
-      shadowsArray.push(serializedShadow);
-    }
-
-    const usedIndex = shadow ? getShadowIndex(shadow, item, index) : null;
-    // @ts-ignore
-    if (overrideCollection.add(item, usedIndex) >= 0) {
-      if (shadow) {
-        overrideCollection.replaced.raiseEvent(item);
-      }
-      return item;
-    }
-    return null;
-  };
-
-  /**
-   * @param {Array<Object>} configArray
-   * @param {string} contextId
-   * @returns {Promise<void>}
-   */
-  overrideCollection.parseItems = async function parseItems(configArray, contextId) {
-    if (Array.isArray(configArray)) {
-      const instanceArray = await Promise.all(configArray.map(async (config) => {
-        const item = await deserialize(config);
-        if (!item || (ctor && !(item instanceof ctor))) {
-          getLogger().warning(`Could not load item ${config[overrideCollection.uniqueKey]} of type ${config.type}`);
-          return null;
-        }
-        item[contextIdSymbol] = contextId;
-        return item;
-      }));
-      instanceArray
-        .filter(i => i)
-        .forEach((i) => { overrideCollection.override(i); });
-    }
-  };
-
-  overrideCollection.removed.addEventListener(async (item) => {
-    const itemId = item[overrideCollection.uniqueKey];
-
-    if (overrideCollection.shadowMap.has(itemId)) {
-      const serializedShadow = overrideCollection.shadowMap.get(itemId).pop();
-      if (serializedShadow) {
-        const reincarnation = await deserialize(serializedShadow);
-        reincarnation[contextIdSymbol] = serializedShadow[contextIdSymbol];
-        // @ts-ignore
-        const index = getShadowIndex(reincarnation, item, item[overrideCollection.previousIndexSymbol]);
-        // @ts-ignore
-        overrideCollection.add(reincarnation, index);
-      }
-
-      if (overrideCollection.shadowMap.get(itemId).length === 0) {
-        overrideCollection.shadowMap.delete(itemId);
-      }
-    }
-  });
-
-  overrideCollection.added.addEventListener((item) => {
-    if (!item[contextIdSymbol]) {
-      item[contextIdSymbol] = getDynamicContextId();
-    }
-  });
-
-  /**
-   * @param {string} contextId
-   * @returns {Promise<void>}
-   */
-  overrideCollection.removeContext = async function removeContext(contextId) {
-    overrideCollection.shadowMap.forEach((shadowsArray, name) => {
-      const newShadowsArray = shadowsArray.filter(c => c[contextIdSymbol] !== contextId);
-      if (newShadowsArray.length === 0) {
-        overrideCollection.shadowMap.delete(name);
-      } else if (newShadowsArray.length !== shadowsArray.length) {
-        overrideCollection.shadowMap.set(name, newShadowsArray);
-      }
-    });
-
-    await Promise.all([...overrideCollection]
-      .filter(item => item[contextIdSymbol] === contextId)
-      .map(async (item) => {
-        overrideCollection.remove(item);
-        // @ts-ignore
-        if (item.destroy) {
-          // @ts-ignore
-          item.destroy();
-        }
-      }));
-  };
-
-  /**
-   * @type {VcsEvent<T>}
-   */
-  overrideCollection.replaced = new VcsEvent();
-
-  /**
-   * @param {string} contextId
-   * @returns {Array<Object>}
-   */
-  overrideCollection.serializeContext = function serializeContext(contextId) {
-    return [...overrideCollection]
-      .map((item) => {
-        if (item[contextIdSymbol] === contextId) {
-          return serialize(item);
-        }
-        if (overrideCollection.shadowMap.has(item[overrideCollection.uniqueKey])) {
-          return overrideCollection.shadowMap.get(item[overrideCollection.uniqueKey])
-            .find(i => i[contextIdSymbol] === contextId);
-        }
-        return null;
-      })
-      .filter(i => i);
-  };
-
-  const originalDestroy = overrideCollection.destroy.bind(overrideCollection);
-
-  overrideCollection.destroy = function destroy() {
-    originalDestroy();
-    overrideCollection.shadowMap.clear();
-    overrideCollection.replaced.destroy();
-  };
-
-  return overrideCollection;
-}
-
-export default makeOverrideCollection;

package/src/util/projection.js

@@ -1,366 +0,0 @@
-import { getTransform, get as getProjection, equivalent } from 'ol/proj.js';
-import { register } from 'ol/proj/proj4.js';
-import proj4 from 'proj4';
-import { check } from '@vcsuite/check';
-import { VcsClassRegistry } from '../classRegistry.js';
-
-/**
- * @typedef {Object} ProjectionOptions
- * @property {string} [type]
- * @property {string|number} [epsg] -  EPSG of the projection, for example: "EPSG:4326" if not specified, uses the framework projection
- * @property {string|undefined|null} [proj4] - definition of the projection. See for example: {@link http://spatialreference.org/ref/epsg/4326/proj4/} proj4
- * @property {Array<string>|undefined|null} [alias] - aliases to define
- * @property {string|undefined} [prefix='EPSG:'] - an alternate prefix to use for custom projection
- * @api stable
- */
-/**
- * @typedef {function(Array<number>, Array<number>=, number=): Array<number>} CorrectTransformFunction
- */
-
-export const wgs84ToMercatorTransformer = /** @type {CorrectTransformFunction} */ (getTransform('EPSG:4326', 'EPSG:3857'));
-export const mercatorToWgs84Transformer = /** @type {CorrectTransformFunction} */ (getTransform('EPSG:3857', 'EPSG:4326'));
-
-/**
- * @type {ProjectionOptions}
- */
-let defaultProjectionOption = {
-  epsg: 'EPSG:4326',
-};
-
-/**
- * @param {string|number} value
- * @param {string=} [prefix="EPSG:"]
- * @returns {string}
- */
-function parseEPSGCode(value, prefix = 'EPSG:') {
-  const regex = new RegExp(`^(?:${prefix})?(\\d+)`, 'i');
-  const matches = `${value}`.match(regex);
-  if (matches && matches[1]) {
-    return `${prefix}${matches[1]}`;
-  }
-  return '';
-}
-
-/**
- * @param {ProjectionOptions} options
- * @returns {boolean}
- */
-function validateProjectionOptions(options) {
-  let proj = null;
-  if (options.epsg) {
-    try {
-      // @ts-ignore
-      proj = proj4(parseEPSGCode(options.epsg));
-    } catch (error) {
-      proj = null;
-    }
-  }
-  if (options.proj4) {
-    try {
-      // @ts-ignore
-      proj = proj4(options.proj4);
-    } catch (error) {
-      proj = null;
-    }
-  }
-  return proj != null;
-}
-
-/**
- * @param {ProjectionOptions} options
- * @returns {ProjectionOptions} valid options
- */
-function registerProjection(options) {
-  const saneOptions = {
-    prefix: options.prefix,
-  };
-  if (options.epsg) {
-    saneOptions.epsg = parseEPSGCode(options.epsg, options.prefix);
-    if (saneOptions.epsg) {
-      if (options.proj4) {
-        saneOptions.proj4 = options.proj4;
-        proj4.defs(saneOptions.epsg, options.proj4);
-        register(proj4);
-      }
-      if (options.alias && Array.isArray(options.alias)) {
-        saneOptions.alias = options.alias;
-        saneOptions.alias.forEach((alias) => {
-          proj4.defs(alias, proj4.defs(saneOptions.epsg));
-          register(proj4);
-        });
-      }
-    }
-  }
-  return saneOptions;
-}
-
-/**
- * Set the default projections epsg and proj4. Does not update
- * projection created prior to this functions call.
- * @param {ProjectionOptions} options
- * @api
- * @export
- */
-export function setDefaultProjectionOptions(options) {
-  check(options, { epsg: [String, Number], proj4: [String, undefined, null] });
-  if (!validateProjectionOptions(options)) {
-    throw new Error('Cannot set invalid projection options as default options');
-  }
-  defaultProjectionOption = registerProjection(options);
-}
-
-/**
- * Projection Class, if no valid options are given, the Projection will initialize with the Framework default Projection
- * @class
- * @export
- * For example:
- *     <pre><code>
- *         {
- *          "epsg" : "EPSG:25833"
- *          "proj4" : "+proj=utm +zone=33 +ellps=GRS80 +units=m +no_defs"
- *         }
- *     </code></pre>
- * @api stable
- */
-class Projection {
-  /**
-   * @returns {string}
-   */
-  static get className() { return 'Projection'; }
-
-  /**
-   * @param {ProjectionOptions} options
-   */
-  constructor(options = { epsg: '' }) {
-    const saneOptions = registerProjection(options);
-    /**
-     * @type {string|null}
-     * @private
-     */
-    this._proj4 = saneOptions.proj4;
-
-    /**
-     * @type {string}
-     * @private
-     */
-    this._epsg = /** @type {string} */ (saneOptions.epsg);
-
-    if (!this.proj) {
-      this._epsg = Projection.parseEPSGCode(defaultProjectionOption.epsg);
-    }
-
-    /**
-     * Cached for toJSON
-     * @type {Array<string>}
-     * @private
-     */
-    this._alias = saneOptions.alias;
-
-    /**
-     * Cached for toJSON
-     * @type {string}
-     * @private
-     */
-    this._prefix = saneOptions.prefix;
-  }
-
-  /**
-   * epsg code in the format "EPSG:25832"
-   * @type {string}
-   * @api
-   * @readonly
-   */
-  get epsg() {
-    return this._epsg;
-  }
-
-  /**
-   * proj4js string example for epsg:25832: +proj=utm +zone=33 +ellps=GRS80 +units=m +no_defs
-   * @type {string|null}
-   * @api
-   * @readonly
-   */
-  get proj4() {
-    return this._proj4;
-  }
-
-  /**
-   * @type {import("ol/proj/Projection").default}
-   * @api
-   * @readonly
-   */
-  get proj() {
-    return getProjection(this.epsg);
-  }
-
-  /**
-   * @param {Projection} projection
-   * @returns {boolean}
-   */
-  equals(projection) {
-    return equivalent(this.proj, projection.proj);
-  }
-
-  /**
-   * @static
-   * @param {Projection} dest
-   * @param {Projection} source
-   * @param {import("ol/coordinate").Coordinate} coords
-   * @returns {import("ol/coordinate").Coordinate}
-   * @api stable
-   */
-  static transform(dest, source, coords) {
-    const transformer = getTransform(source.proj, dest.proj);
-    const newCoords = new Array(2);
-    transformer([coords[0], coords[1]], newCoords, 2);
-    if (coords.length > 2) {
-      newCoords.push(coords[2]);
-    }
-    return newCoords;
-  }
-
-  /**
-   * @param {Projection} dest
-   * @param {import("ol/coordinate").Coordinate} coords
-   * @returns {import("ol/coordinate").Coordinate}
-   * @api stable
-   */
-  transformTo(dest, coords) {
-    return Projection.transform(dest, this, coords);
-  }
-
-  /**
-   * @static
-   * @param {Projection} dest
-   * @param {Projection} source
-   * @param {Array.<import("ol/coordinate").Coordinate>} coords
-   * @returns {Array.<import("ol/coordinate").Coordinate>}
-   * @api stable
-   */
-  static transformCoordinates(dest, source, coords) {
-    const newCoords = [];
-    for (let i = 0; i < coords.length; i++) {
-      newCoords.push(Projection.transform(dest, source, coords[i]));
-    }
-    return newCoords;
-  }
-
-  /**
-   * returns a function to transform coordinates from source to dest
-   * @static
-   * @param {Projection} dest
-   * @param {Projection} source
-   * @returns {import("ol/proj").TransformFunction}
-   */
-  static getTransformer(dest, source) {
-    return getTransform(source.proj, dest.proj);
-  }
-
-  /**
-   * @param {Projection} source
-   * @param {import("ol/coordinate").Coordinate} coords
-   * @returns {import("ol/coordinate").Coordinate}
-   * @api stable
-   */
-  transformFrom(source, coords) {
-    return Projection.transform(this, source, coords);
-  }
-
-  /**
-   * Returns the object literal representation of this object
-   * @returns {ProjectionOptions}
-   * @api stable
-   */
-  toJSON() {
-    const configObject = {
-      type: Projection.className,
-      epsg: this.epsg,
-    };
-    if (this.proj4) {
-      configObject.proj4 = this.proj4;
-    }
-    if (Array.isArray(this._alias) && this._alias.length > 0) {
-      configObject.alias = this._alias.slice();
-    }
-    if (this._prefix) {
-      configObject.prefix = this._prefix;
-    }
-    return configObject;
-  }
-
-  /**
-   * Fast transform from Web-Mercator to WGS84
-   * @param {import("ol/coordinate").Coordinate} coords
-   * @param {boolean=} inPlace - whether to transform in place
-   * @returns {import("ol/coordinate").Coordinate}
-   * @api
-   */
-  static mercatorToWgs84(coords, inPlace) {
-    return mercatorToWgs84Transformer(coords, inPlace ? coords : undefined, coords.length);
-  }
-
-  /**
-   * Fast transform from WGS84 to Web-Mercator
-   * @param {import("ol/coordinate").Coordinate} coords
-   * @param {boolean=} inPlace - whether to transform in place
-   * @returns {import("ol/coordinate").Coordinate}
-   * @api
-   */
-  static wgs84ToMercator(coords, inPlace) {
-    return wgs84ToMercatorTransformer(coords, inPlace ? coords : undefined, coords.length);
-  }
-
-  /**
-   * validates projection options, combination of epsg code and proj4
-   * @param {ProjectionOptions} options
-   * @returns {boolean}
-   * @api
-   */
-  static validateOptions(options) {
-    return validateProjectionOptions(options);
-  }
-
-  /**
-   * parses an epsg code returns empty string if no code has been found
-   * for example:
-   * parseEPSGCode('epsg:4326') ==> '4326'
-   * parseEPSGCode('epsg:4326', 'EPSG:') ==> 'EPSG:4326'
-   * parseEPSGCode('asdasd', 'EPSG:') ==> ''
-   * @param {string|number|undefined} value
-   * @param {string|undefined} prefix default EPSG:
-   * @returns {string}
-   * @api
-   */
-  static parseEPSGCode(value, prefix = 'EPSG:') {
-    return parseEPSGCode(value, prefix);
-  }
-}
-
-export default Projection;
-
-/**
- * Returns the default Projection.
- * @api stable
- * @returns {Projection}
- * @export
- */
-export function getDefaultProjection() {
-  return new Projection(defaultProjectionOption);
-}
-
-/**
- * wgs84 Projection EPSG Code: 4326
- * @api stable
- * @type {Projection}
- * @export
- */
-export const wgs84Projection = new Projection({ epsg: 4326 });
-/**
- * mercator Projection EPSG Code: 3857
- * @api stable
- * @type {Projection}
- * @export
- */
-export const mercatorProjection = new Projection({ epsg: 3857 });
-
-VcsClassRegistry.registerClass(Projection.className, Projection);