@vcmap/core 5.0.0-rc.8 → 5.0.0

package/src/util/{collection.js → collection.ts}

@@ -2,24 +2,20 @@ import VcsEvent from '../vcsEvent.js';
 
 /**
  * A generic array based collection. Implements the Symbol.iterator (e.g. [...collection])
- * @class
- * @export
- * @template {*} T
- * @api
  */
-class Collection {
+class Collection<T> {
   /**
    * Creates a Collection from an iterable, such as an Array.
-   * @template {*} T
-   * @param {Iterable<T>} iterable
-   * @param {(string|symbol|boolean)=} [uniqueKey='name'] - a key to maintain uniquely within the collection. passing false disables uniqueness.
-   * @returns {Collection<T>}
-   * @api
+   * @template  T
+   * @param  iterable
+   * @param  [uniqueKey='name'] - a key to maintain uniquely within the collection. passing false disables uniqueness.
    */
-  static from(iterable, uniqueKey) {
-    const collection = /** @type {Collection<T>} */ (new Collection(uniqueKey));
+  static from<F>(
+    iterable: Iterable<F>,
+    uniqueKey?: keyof F | false,
+  ): Collection<F> {
+    const collection: Collection<F> = new Collection(uniqueKey);
     if (iterable) {
-      // eslint-disable-next-line no-restricted-syntax
       for (const i of iterable) {
         collection.add(i);
       }
@@ -27,43 +23,38 @@ class Collection {
     return collection;
   }
 
+  protected _array: Array<T>;
+
+  private readonly _uniqueKey: keyof T | undefined;
+
   /**
-   * @param {(string|symbol|boolean)=} [uniqueKey='name'] - a key to maintain uniquely within the collection. passing false disables uniqueness.
+   * Event raised if an item is added. Is passed the added item.
    */
-  constructor(uniqueKey) {
-    /**
-     * @protected
-     * @type {Array<T>}
-     */
-    this._array = [];
+  added: VcsEvent<T>;
 
-    /**
-     * @type {string|symbol}
-     * @private
-     */
-    this._uniqueKey = 'name';
+  /**
+   * Event raised if an item is removed. Is passed the removed item.
+   */
+  removed: VcsEvent<T>;
+
+  /**
+   * @param  [uniqueKey='name'] - a key to maintain uniquely within the collection. passing false disables uniqueness.
+   */
+  constructor(uniqueKey?: keyof T | false) {
+    this._array = [];
+    this._uniqueKey = 'name' as keyof T;
     if (typeof uniqueKey === 'string' || typeof uniqueKey === 'symbol') {
       this._uniqueKey = uniqueKey;
     } else if (uniqueKey === false) {
       this._uniqueKey = undefined;
     }
 
-    /**
-     * Event raised if an item is added. Is passed the added item.
-     * @type {VcsEvent<T>}
-     * @api
-     */
     this.added = new VcsEvent();
 
-    /**
-     * Event raised if an item is removed. Is passed the removed item.
-     * @type {VcsEvent<T>}
-     * @api
-     */
     this.removed = new VcsEvent();
   }
 
-  * [Symbol.iterator]() {
+  *[Symbol.iterator](): Generator<T> {
     const arrayLength = this._array.length;
     for (let i = 0; i < arrayLength; i++) {
       yield this._array[i];
@@ -72,38 +63,27 @@ class Collection {
 
   /**
    * The key by which to check uniqueness against. undefined if no uniqueness constraint is set.
-   * @readonly
-   * @type {string|symbol}
-   * @api
    */
-  get uniqueKey() { return this._uniqueKey; }
+  get uniqueKey(): keyof T | undefined {
+    return this._uniqueKey;
+  }
 
-  /**
-   * @readonly
-   * @type {number}
-   * @api
-   */
-  get size() { return this._array.length; }
+  get size(): number {
+    return this._array.length;
+  }
 
   /**
    * Returns an item identified by the unique constraint key. Returns null, if there is no uniqueness constraint.
-   * @param {*} value - the value to test against. does a shallow comparison, if the passed a non-atomic value
-   * @returns {T|undefined}
-   * @api
+   * @param  value - the value to test against. does a shallow comparison, if the passed a non-atomic value
    */
-  getByKey(value) {
+  getByKey(value: unknown): T | undefined {
     if (!this._uniqueKey) {
       return undefined;
     }
-    return this._array.find(e => e[this._uniqueKey] === value);
+    return this._array.find((e) => e[this._uniqueKey as keyof T] === value);
   }
 
-  /**
-   * @param {T} item
-   * @returns {boolean}
-   * @protected
-   */
-  _checkUniqueness(item) {
+  protected _checkUniqueness(item: T): boolean {
     if (this._uniqueKey) {
       if (item == null || typeof item !== 'object') {
         return false;
@@ -122,11 +102,10 @@ class Collection {
 
   /**
    * Adds an item to the collection.
-   * @param {T} item - the item to be inserted
-   * @returns {number|null} the index at which the item was inserted
-   * @api
+   * @param  item - the item to be inserted
+   * @returns  the index at which the item was inserted
    */
-  add(item) {
+  add(item: T): number | null {
     if (this._checkUniqueness(item)) {
       this._array.push(item);
       this.added.raiseEvent(item);
@@ -136,54 +115,63 @@ class Collection {
   }
 
   /**
-   * Removes an item from the collection
-   * @param {T} item
-   * @api
+   * internal remove function, to remove an item from the collection, does not raise an event.
+   * @param  item
+   * @returns  returns the index of the removed item or -1 if the item has not been found.
+   * @protected
    */
-  remove(item) {
+  protected _remove(item: T): number {
     const index = this._array.indexOf(item);
     if (index > -1) {
       this._array.splice(index, 1);
+    }
+    return index;
+  }
+
+  /**
+   * Removes an item from the collection
+   * @param  item
+   */
+  remove(item: T): void {
+    const index = this._remove(item);
+    if (index > -1) {
       this.removed.raiseEvent(item);
     }
   }
 
   /**
    * Equivalent to Array.prototype.includes
-   * @param {T} item
-   * @returns {boolean}
-   * @api
+   * @param  item
    */
-  has(item) {
+  has(item: T): boolean {
     return this._array.includes(item);
   }
 
   /**
    * Returns true, if the key exists. Returns undefined, if there is no uniqueness constraint.
-   * @param {*} value
-   * @returns {boolean}
-   * @api
+   * @param  value
    */
-  hasKey(value) {
+  hasKey(value: unknown): boolean | undefined {
     if (!this._uniqueKey) {
       return undefined;
     }
-    return this._array.some(e => e[this._uniqueKey] === value);
+    return this._array.some((e) => e[this._uniqueKey as keyof T] === value);
   }
 
   /**
    * clears the array
-   * @api
    */
-  clear() {
-    this._array.forEach((i) => { this.removed.raiseEvent(i); });
+  clear(): void {
+    this._array.forEach((i) => {
+      this.removed.raiseEvent(i);
+    });
     this._array.splice(0);
   }
 
   /**
    * Destroys the collection, clearing the array and all its events
    */
-  destroy() {
+  destroy(): void {
     this._array = [];
     this.added.destroy();
     this.removed.destroy();

package/src/util/editor/createFeatureSession.ts

@@ -0,0 +1,241 @@
+import { check } from '@vcsuite/check';
+import { Feature } from 'ol';
+import type { Geometry } from 'ol/geom.js';
+import VcsEvent from '../../vcsEvent.js';
+import {
+  EditorSession,
+  GeometryToType,
+  GeometryType,
+  SessionType,
+  setupInteractionChain,
+} from './editorSessionHelpers.js';
+import CreateLineStringInteraction from './interactions/createLineStringInteraction.js';
+import CreateCircleInteraction from './interactions/createCircleInteraction.js';
+import CreateBBoxInteraction from './interactions/createBBoxInteraction.js';
+import CreatePointInteraction from './interactions/createPointInteraction.js';
+import CreatePolygonInteraction from './interactions/createPolygonInteraction.js';
+import VcsApp from '../../vcsApp.js';
+import VectorLayer from '../../layer/vectorLayer.js';
+import { createSync } from '../../layer/vectorSymbols.js';
+import geometryIsValid from './validateGeoemetry.js';
+import ObliqueMap from '../../map/obliqueMap.js';
+import { cursorMap } from './interactions/editGeometryMouseOverInteraction.js';
+
+export type CreateFeatureSession<T extends GeometryType> = EditorSession & {
+  geometryType: T;
+  featureCreated: VcsEvent<Feature<GeometryToType<T>>>;
+  creationFinished: VcsEvent<Feature<GeometryToType<T>> | null>;
+  finish(): void;
+};
+
+type InteractionOfGeometryType<T extends GeometryType> =
+  T extends GeometryType.Point
+    ? CreatePointInteraction
+    : T extends GeometryType.Polygon
+    ? CreatePolygonInteraction
+    : T extends GeometryType.LineString
+    ? CreateLineStringInteraction
+    : T extends GeometryType.BBox
+    ? CreateBBoxInteraction
+    : T extends GeometryType.Circle
+    ? CreateCircleInteraction
+    : never;
+
+function createInteractionForGeometryType<T extends GeometryType>(
+  geometryType: T,
+): InteractionOfGeometryType<T> {
+  let currentInteraction;
+  if (geometryType === GeometryType.Polygon) {
+    currentInteraction = new CreatePolygonInteraction();
+  } else if (geometryType === GeometryType.Point) {
+    currentInteraction = new CreatePointInteraction();
+  } else if (geometryType === GeometryType.LineString) {
+    currentInteraction = new CreateLineStringInteraction();
+  } else if (geometryType === GeometryType.BBox) {
+    currentInteraction = new CreateBBoxInteraction();
+  } else if (geometryType === GeometryType.Circle) {
+    currentInteraction = new CreateCircleInteraction();
+  } else {
+    throw new Error(`Unexpected geometry tpye ${geometryType}`);
+  }
+  return currentInteraction as InteractionOfGeometryType<T>;
+}
+
+/**
+ * This is a common interface for all geometry creation interactions.
+ * The interaction shall be active on creation.
+ * On click, the interaction shall create a geometry and raise the created event with said geoemtry
+ * To deactivate (finish) an active interaction, call finish instead of setActive.
+ * An interaction shall be finishable via a double click.
+ * On finish, the finished event shall be called with the now finished geometry.
+ * Said geometry may be invalid.
+ * Geometries created may be in pixel coordinates. Appropriate symbols shall be set by the interaction.
+ */
+export interface CreateInteraction<T extends Geometry> {
+  finish(): void;
+  finished: VcsEvent<T | null>;
+  created: VcsEvent<T>;
+  destroy(): void;
+}
+
+/**
+ * Creates an editor session to create features of the given geometry type.
+ * While the session is active: Do not change the geometry on the current feature (the last created one)
+ * and do not change crucial olcs properties on the feature or the layer (olcs_altitudeMode)
+ * @param  app
+ * @param  layer
+ * @param  geometryType
+ * @group Editor
+ */
+function startCreateFeatureSession<T extends GeometryType>(
+  app: VcsApp,
+  layer: VectorLayer,
+  geometryType: T,
+): CreateFeatureSession<T> {
+  check(app, VcsApp);
+  check(layer, VectorLayer);
+  check(geometryType, Object.values(GeometryType));
+
+  const {
+    interactionChain,
+    removed: interactionRemoved,
+    destroy: destroyInteractionChain,
+  } = setupInteractionChain(app.maps.eventHandler);
+
+  const featureCreated = new VcsEvent<Feature<GeometryToType<T>>>();
+  const creationFinished = new VcsEvent<Feature<GeometryToType<T>> | null>();
+  const stopped = new VcsEvent<void>();
+  let isStopped = false;
+
+  let currentInteraction: InteractionOfGeometryType<T> | null = null;
+  let currentFeature: Feature<GeometryToType<T>> | null = null;
+
+  /**
+   * Ture if the currently active map is an ObliqueMap. set in setupActiveMap
+   */
+  let isOblique = false;
+
+  let interactionListeners: (() => void)[] = [];
+  const destroyCurrentInteraction = (): void => {
+    if (currentInteraction) {
+      interactionChain.removeInteraction(currentInteraction);
+      currentInteraction.destroy();
+      currentInteraction = null;
+    }
+    interactionListeners.forEach((cb) => {
+      cb();
+    });
+    interactionListeners = [];
+  };
+
+  const createInteraction = (): void => {
+    destroyCurrentInteraction();
+    currentInteraction = createInteractionForGeometryType(geometryType);
+
+    interactionListeners = [
+      currentInteraction.created.addEventListener((geometry) => {
+        if (isOblique) {
+          (app.maps.activeMap as ObliqueMap).switchEnabled = false;
+        }
+        currentFeature = new Feature({ geometry }) as Feature<
+          GeometryToType<T>
+        >;
+        currentFeature[createSync] = true;
+        layer.addFeatures([currentFeature]);
+        featureCreated.raiseEvent(currentFeature);
+      }),
+      currentInteraction.finished.addEventListener((geometry) => {
+        if (isOblique) {
+          (app.maps.activeMap as ObliqueMap).switchEnabled = true;
+        }
+        if (currentFeature) {
+          delete currentFeature[createSync];
+          if (
+            !geometry ||
+            currentFeature.getGeometry() !== geometry ||
+            !geometryIsValid(geometry)
+          ) {
+            layer.removeFeaturesById([
+              currentFeature.getId() as string | number,
+            ]);
+            currentFeature = null;
+          }
+        }
+
+        creationFinished.raiseEvent(currentFeature);
+        currentFeature = null;
+        if (!isStopped) {
+          createInteraction();
+        }
+      }),
+    ];
+    interactionChain.addInteraction(currentInteraction);
+  };
+  createInteraction();
+
+  const resetCurrentInteraction = (): void => {
+    if (currentInteraction) {
+      currentInteraction.finish();
+    }
+    createInteraction();
+  };
+
+  let obliqueImageChangedListener = (): void => {};
+  const setupActiveMap = (): void => {
+    obliqueImageChangedListener();
+    const { activeMap } = app.maps;
+    isOblique = activeMap instanceof ObliqueMap;
+    if (isOblique) {
+      obliqueImageChangedListener =
+        (activeMap as ObliqueMap).imageChanged?.addEventListener(
+          resetCurrentInteraction,
+        ) ?? ((): void => {});
+    } else {
+      obliqueImageChangedListener = (): void => {};
+    }
+  };
+
+  const mapChangedListener = app.maps.mapActivated.addEventListener(() => {
+    setupActiveMap();
+    resetCurrentInteraction();
+  });
+  setupActiveMap();
+
+  if (app.maps.target) {
+    app.maps.target.style.cursor = cursorMap.edit;
+  }
+
+  const stop = (): void => {
+    isStopped = true; // setting stopped true immediately, to prevent the recreation of the interaction chain on finished
+    if (app.maps.target) {
+      app.maps.target.style.cursor = cursorMap.auto;
+    }
+    mapChangedListener();
+    obliqueImageChangedListener();
+    if (currentInteraction) {
+      currentInteraction.finish();
+    }
+    destroyCurrentInteraction();
+    destroyInteractionChain();
+    stopped.raiseEvent();
+    stopped.destroy();
+    featureCreated.destroy();
+  };
+  interactionRemoved.addEventListener(stop);
+
+  return {
+    type: SessionType.CREATE,
+    geometryType,
+    featureCreated,
+    creationFinished,
+    stopped,
+    finish: (): void => {
+      if (currentInteraction) {
+        currentInteraction.finish();
+      }
+    },
+    stop,
+  };
+}
+
+export default startCreateFeatureSession;