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

package/src/layer/{featureStoreLayerChanges.js → featureStoreLayerChanges.ts}

@@ -1,5 +1,9 @@
 import { unByKey } from 'ol/Observable.js';
 import Feature from 'ol/Feature.js';
+import { EventsKey } from 'ol/events.js';
+import { GeoJSONFeature } from 'ol/format/GeoJSON.js';
+import type { VectorSourceEvent } from 'ol/source/Vector.js';
+
 import { check } from '@vcsuite/check';
 import {
   FeatureStoreLayerState,
@@ -9,43 +13,37 @@ import { parseGeoJSON, writeGeoJSONFeature } from './geojsonHelpers.js';
 import VcsObject from '../vcsObject.js';
 import { requestJson } from '../util/fetch.js';
 
-/**
- * @typedef {Object} FeatureStoreTrackResults
- * @property {Array<import("ol").Feature<import("ol/geom/Geometry").default>>} add
- * @property {Array<import("ol").Feature<import("ol/geom/Geometry").default>>} edit
- * @property {Array<import("ol").Feature<import("ol/geom/Geometry").default>>} remove
- * @api
- */
-
-/**
- * @typedef {Object} FeatureStoreChangesListeners
- * @property {import("ol/events").EventsKey|Array<import("ol/events").EventsKey>|null} addfeature
- * @property {import("ol/events").EventsKey|Array<import("ol/events").EventsKey>|null} changefeature
- * @property {import("ol/events").EventsKey|Array<import("ol/events").EventsKey>|null} removefeature
- */
-
-/**
- * @typedef {Object} FeatureStoreChangesValues
- * @property {boolean} changed
- */
-
-/**
- * @typedef {Object} CommitAction
- * @property {string} action
- * @property {import("ol/format/GeoJSON").GeoJSONFeature} feature
- * @property {import("ol").Feature<import("ol/geom/Geometry").default>} original
- * @property {function(string=):void} success
- */
-
-/**
- * @param {Set<import("ol").Feature<import("ol/geom/Geometry").default>>} added
- * @param {Set<import("ol").Feature<import("ol/geom/Geometry").default>>} edited
- * @param {Set<import("ol").Feature<import("ol/geom/Geometry").default>>} removed
- * @returns {Array<CommitAction>}
- * @private
- */
-export function createCommitActions(added, edited, removed) {
-  const actions = [];
+import type FeatureStoreLayer from './featureStoreLayer.js';
+
+export type FeatureStoreTrackResults = {
+  add: Feature[];
+  edit: Feature[];
+  remove: Feature[];
+};
+
+export type FeatureStoreChangesListeners = {
+  addfeature: EventsKey | EventsKey[] | null;
+  changefeature: EventsKey | EventsKey[] | null;
+  removefeature: EventsKey | EventsKey[] | null;
+};
+
+export type FeatureStoreChangesValues = {
+  changed: boolean;
+};
+
+type CommitAction = {
+  action: string;
+  feature: GeoJSONFeature | { _id: string | number | undefined };
+  original: Feature;
+  success(opt?: string): void;
+};
+
+export function createCommitActions(
+  added: Set<Feature>,
+  edited: Set<Feature>,
+  removed: Set<Feature>,
+): CommitAction[] {
+  const actions: CommitAction[] = [];
   added.forEach((f) => {
     const feature = writeGeoJSONFeature(f, { writeStyle: true });
     actions.push({
@@ -62,7 +60,6 @@ export function createCommitActions(added, edited, removed) {
   edited.forEach((f) => {
     const feature = writeGeoJSONFeature(f, { writeStyle: true });
     feature._id = f.getId();
-    feature.geomety = 'test'; // XXX why test???
     actions.push({
       action: 'edit',
       original: f,
@@ -76,11 +73,10 @@ export function createCommitActions(added, edited, removed) {
   });
 
   removed.forEach((f) => {
-    const _id = f.getId();
     actions.push({
       original: f,
       action: 'remove',
-      feature: { _id },
+      feature: { _id: f.getId() },
       success() {},
     });
   });
@@ -90,59 +86,56 @@ export function createCommitActions(added, edited, removed) {
 
 /**
  * do not construct directly, use the layers .changeTracker instead
- * @class
- * @extends {VcsObject}
- * @api
  */
 class FeatureStoreLayerChanges extends VcsObject {
-  static get className() {
+  static get className(): string {
     return 'FeatureStoreLayerChanges';
   }
 
-  /**
-   * @param {import("@vcmap/core").FeatureStoreLayer} layer
-   */
-  constructor(layer) {
+  private _layer: FeatureStoreLayer | undefined;
+
+  private _changesListeners: FeatureStoreChangesListeners = {
+    addfeature: null,
+    changefeature: null,
+    removefeature: null,
+  };
+
+  private _addedFeatures: Set<Feature> = new Set();
+
+  private _editedFeatures: Set<Feature> = new Set();
+
+  private _removedFeatures: Set<Feature> = new Set();
+
+  private _convertedFeatures: Set<Feature> = new Set();
+
+  values: FeatureStoreChangesValues = {
+    changed: false,
+  };
+
+  constructor(layer: FeatureStoreLayer) {
     super({});
+    this._layer = layer;
+  }
 
-    /** @type {import("@vcmap/core").FeatureStoreLayer} */
-    this.layer = layer;
-    /** @type {FeatureStoreChangesListeners} */
-    this._changesListeners = {
-      addfeature: null,
-      changefeature: null,
-      removefeature: null,
-    };
-    /** @type {Set<import("ol").Feature<import("ol/geom/Geometry").default>>} */
-    this._addedFeatures = new Set();
-    /** @type {Set<import("ol").Feature<import("ol/geom/Geometry").default>>} */
-    this._editedFeatures = new Set();
-    /** @type {Set<import("ol").Feature<import("ol/geom/Geometry").default>>} */
-    this._removedFeatures = new Set();
-    /** @type {Set<import("ol").Feature<import("ol/geom/Geometry").default>>} */
-    this._convertedFeatures = new Set();
-    /** @type {FeatureStoreChangesValues} */
-    this.values = {
-      changed: false,
-    };
+  get layer(): FeatureStoreLayer {
+    if (!this._layer) {
+      throw new Error('Trying to access destroyed feature store changes');
+    }
+    return this._layer;
   }
 
   /**
    * Whether changes are being tracked or not
-   * @readonly
-   * @returns {boolean}
-   * @api
    */
-  get active() {
+  get active(): boolean {
     return Object.values(this._changesListeners).some((c) => c !== null);
   }
 
   /**
    * starts tracking changes on the layer
    * starts tracking changes on the feature store layer
-   * @api
    */
-  track() {
+  track(): void {
     if (this._changesListeners.addfeature === null) {
       this._changesListeners.addfeature = this.layer.source.on(
         'addfeature',
@@ -165,10 +158,7 @@ class FeatureStoreLayerChanges extends VcsObject {
     }
   }
 
-  /**
-   * @returns {FeatureStoreTrackResults}
-   */
-  getChanges() {
+  getChanges(): FeatureStoreTrackResults {
     return {
       add: [...this._addedFeatures],
       edit: [...this._editedFeatures],
@@ -178,45 +168,47 @@ class FeatureStoreLayerChanges extends VcsObject {
 
   /**
    * commits the changes to the provided url. url should contain accessTokens and point to a featureStore layers bulk operation endpoint
-   * @param {string} url
-   * @param {Object<string, string>=} headers
-   * @returns {Promise<void>}
-   * @api
    */
-  async commitChanges(url, headers = {}) {
-    const actions = createCommitActions(
+  async commitChanges(
+    url: string,
+    headers: Record<string, string> = {},
+  ): Promise<void> {
+    const actions: (CommitAction | null)[] = createCommitActions(
       this._addedFeatures,
       this._editedFeatures,
       this._removedFeatures,
     );
     if (actions.length > 0) {
-      const data = await requestJson(url.toString(), {
+      const data = await requestJson<{
+        failedActions: { index: number; error: string }[];
+        insertedIds: { _id: string }[];
+      }>(url.toString(), {
         method: 'POST',
         headers: {
           ...headers,
           'Content-Type': 'application/json',
         },
         body: JSON.stringify(
-          actions.map((a) => ({ action: a.action, feature: a.feature })),
+          actions.map((a) => ({ action: a!.action, feature: a!.feature })),
         ),
       });
 
       const failures = data.failedActions.map(({ index, error }) => {
-        const action = actions[index];
+        const action = actions[index] as CommitAction;
         this.getLogger().log(`failed action ${action.action}: ${error}`);
         actions[index] = null;
         return this._resetFeature(action.original);
       });
 
-      actions
-        .filter((a) => a)
-        .forEach(({ action, success }) => {
-          if (action === 'add') {
-            success(data.insertedIds.shift()._id); // XXX should this be shift or should we find the index?
+      actions.forEach((action) => {
+        if (action) {
+          if (action.action === 'add') {
+            action.success(data.insertedIds.shift()?._id); // XXX should this be shift or should we find the index?
           } else {
-            success();
+            action.success();
           }
-        });
+        }
+      });
       await Promise.all(failures);
     } else {
       try {
@@ -226,7 +218,7 @@ class FeatureStoreLayerChanges extends VcsObject {
           }),
         );
       } catch (err) {
-        this.getLogger().error(err.message);
+        this.getLogger().error(String(err));
       }
       this._resetValues();
     }
@@ -234,11 +226,9 @@ class FeatureStoreLayerChanges extends VcsObject {
 
   /**
    * resets all changes since the last commit or the beginning of tracking
-   * @returns {Promise<void>}
-   * @api
    */
-  async reset() {
-    const promises = [];
+  async reset(): Promise<void> {
+    const promises: Promise<void>[] = [];
     this._addedFeatures.forEach((f) => {
       promises.push(this._resetFeature(f));
     });
@@ -256,18 +246,13 @@ class FeatureStoreLayerChanges extends VcsObject {
         this._resetValues();
       })
       .catch((err) => {
-        this.getLogger().error(err);
+        this.getLogger().error(String(err));
         this._resetValues();
       });
   }
 
-  /**
-   * @param {import("ol").Feature<import("ol/geom/Geometry").default>} feature
-   * @returns {Promise<void>}
-   * @private
-   */
-  _resetFeature(feature) {
-    const featureId = feature.getId();
+  private _resetFeature(feature: Feature): Promise<void> {
+    const featureId = feature.getId() as string | number;
     const idArray = [featureId];
     if (!feature[featureStoreStateSymbol]) {
       this.layer.removeFeaturesById(idArray);
@@ -289,12 +274,12 @@ class FeatureStoreLayerChanges extends VcsObject {
       .catch((err) => {
         this.getLogger().error(
           'failed to reset feature, giving up',
-          err.message,
+          String(err),
         );
       });
   }
 
-  _resetValues() {
+  private _resetValues(): void {
     this._addedFeatures.clear();
     this._editedFeatures.clear();
     this._removedFeatures.clear();
@@ -304,10 +289,11 @@ class FeatureStoreLayerChanges extends VcsObject {
 
   /**
    * stops tracking changes on the feature store layer
-   * @api
    */
-  unTrack() {
-    unByKey(Object.values(this._changesListeners));
+  unTrack(): void {
+    unByKey(
+      Object.values(this._changesListeners).filter((e) => e) as EventsKey[],
+    );
     this._changesListeners.addfeature = null;
     this._changesListeners.changefeature = null;
     this._changesListeners.removefeature = null;
@@ -316,68 +302,63 @@ class FeatureStoreLayerChanges extends VcsObject {
 
   /**
    * pauses the tracking of the given event, but does not reset features
-   * @param {string} event - one of: addfeature, changefeature or removefeature
-   * @api
+   * @param  event - one of: addfeature, changefeature or removefeature
    */
-  pauseTracking(event) {
+  pauseTracking(event: keyof FeatureStoreChangesListeners): void {
     if (this._changesListeners[event]) {
-      unByKey(this._changesListeners[event]);
+      unByKey(this._changesListeners[event] as EventsKey);
       this._changesListeners[event] = null;
     }
   }
 
-  /**
-   * @param {{feature: import("ol").Feature<import("ol/geom/Geometry").default>}} event
-   * @private
-   */
-  _featureAdded(event) {
+  private _featureAdded(event: VectorSourceEvent | { feature: Feature }): void {
     const { feature } = event;
-    if (!feature[featureStoreStateSymbol]) {
-      this._addedFeatures.add(feature);
-      this.values.changed = true;
-    } else if (
-      feature[featureStoreStateSymbol] === FeatureStoreLayerState.STATIC
-    ) {
-      this._convertedFeatures.add(feature);
-      this.values.changed = true;
+    if (feature) {
+      if (!feature[featureStoreStateSymbol]) {
+        this._addedFeatures.add(feature);
+        this.values.changed = true;
+      } else if (
+        feature[featureStoreStateSymbol] === FeatureStoreLayerState.STATIC
+      ) {
+        this._convertedFeatures.add(feature);
+        this.values.changed = true;
+      }
     }
   }
 
-  /**
-   * @param {{feature: import("ol").Feature<import("ol/geom/Geometry").default>}} event
-   * @private
-   */
-  _featureChanged(event) {
+  private _featureChanged(
+    event: VectorSourceEvent | { feature: Feature },
+  ): void {
     const { feature } = event;
-    if (feature[featureStoreStateSymbol]) {
-      this._convertedFeatures.delete(feature);
-      this._editedFeatures.add(feature);
-      this.values.changed = true;
+    if (feature) {
+      if (feature[featureStoreStateSymbol]) {
+        this._convertedFeatures.delete(feature);
+        this._editedFeatures.add(feature);
+        this.values.changed = true;
+      }
     }
   }
 
-  /**
-   * @param {{feature: import("ol").Feature<import("ol/geom/Geometry").default>}} event
-   * @private
-   */
-  _featureRemoved(event) {
+  private _featureRemoved(
+    event: VectorSourceEvent | { feature: Feature },
+  ): void {
     const { feature } = event;
-    if (feature[featureStoreStateSymbol]) {
-      this._removedFeatures.add(feature);
-      this._editedFeatures.delete(feature);
-      this._convertedFeatures.delete(feature);
-      this.values.changed = true;
-    } else {
-      this._addedFeatures.delete(feature);
+    if (feature) {
+      if (feature[featureStoreStateSymbol]) {
+        this._removedFeatures.add(feature);
+        this._editedFeatures.delete(feature);
+        this._convertedFeatures.delete(feature);
+        this.values.changed = true;
+      } else {
+        this._addedFeatures.delete(feature);
+      }
     }
   }
 
   /**
    * tracks the change of removing a static feature
-   * @param {import("ol").Feature<import("ol/geom/Geometry").default>} feature
-   * @api
    */
-  removeFeature(feature) {
+  removeFeature(feature: Feature): void {
     check(feature, Feature);
 
     this._featureRemoved({ feature });
@@ -385,10 +366,8 @@ class FeatureStoreLayerChanges extends VcsObject {
 
   /**
    * adds an addition to the tracker. prefer use of .track
-   * @param {import("ol").Feature<import("ol/geom/Geometry").default>} feature
-   * @api
    */
-  addFeature(feature) {
+  addFeature(feature: Feature): void {
     check(feature, Feature);
 
     this._featureAdded({ feature });
@@ -396,21 +375,16 @@ class FeatureStoreLayerChanges extends VcsObject {
 
   /**
    * adds an edit to the tracker. prefer use of .track
-   * @param {import("ol").Feature<import("ol/geom/Geometry").default>} feature
-   * @api
    */
-  editFeature(feature) {
+  editFeature(feature: Feature): void {
     check(feature, Feature);
 
     this._featureChanged({ feature });
   }
 
-  /**
-   * destroys the Changetracker
-   */
-  destroy() {
+  destroy(): void {
     this.unTrack();
-    this.layer = null;
+    this._layer = undefined;
     super.destroy();
   }
 }

package/src/layer/featureStoreLayerState.ts

@@ -0,0 +1,10 @@
+export const featureStoreStateSymbol = Symbol('vcsFeatureType');
+
+/**
+ * Enumeration of feature store item states
+ */
+export enum FeatureStoreLayerState {
+  DYNAMIC = 'dynamic',
+  STATIC = 'static',
+  EDITED = 'edited',
+}