@vcmap/core 5.0.0-rc.2 → 5.0.0-rc.5

package/src/vcs/vcm/util/projection.js

@@ -3,12 +3,15 @@ import { register } from 'ol/proj/proj4.js';
 import proj4 from 'proj4';
 import { getLogger as getLoggerByName } from '@vcsuite/logger';
 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
  */
 
@@ -36,7 +39,8 @@ let defaultProjectionOption = {
  * @returns {string}
  */
 function parseEPSGCode(value, prefix = 'EPSG:') {
-  const matches = `${value}`.match(/^(?:epsg:)?(\d+)/i);
+  const regex = new RegExp(`^(?:${prefix})?(\\d+)`, 'i');
+  const matches = `${value}`.match(regex);
   if (matches && matches[1]) {
     return `${prefix}${matches[1]}`;
   }
@@ -73,9 +77,11 @@ function validateProjectionOptions(options) {
  * @returns {ProjectionOptions} valid options
  */
 function registerProjection(options) {
-  const saneOptions = {};
+  const saneOptions = {
+    prefix: options.prefix,
+  };
   if (options.epsg) {
-    saneOptions.epsg = parseEPSGCode(options.epsg);
+    saneOptions.epsg = parseEPSGCode(options.epsg, options.prefix);
     if (saneOptions.epsg) {
       if (options.proj4) {
         saneOptions.proj4 = options.proj4;
@@ -123,6 +129,11 @@ export function setDefaultProjectionOptions(options) {
  * @api stable
  */
 class Projection {
+  /**
+   * @returns {string}
+   */
+  static get className() { return 'vcs.vcm.util.Projection'; }
+
   /**
    * @param {ProjectionOptions} options
    */
@@ -143,6 +154,20 @@ class Projection {
     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;
   }
 
   /**
@@ -264,11 +289,18 @@ class Projection {
    */
   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;
   }
 
@@ -346,3 +378,5 @@ export const wgs84Projection = new Projection({ epsg: 4326 });
  * @export
  */
 export const mercatorProjection = new Projection({ epsg: 3857 });
+
+VcsClassRegistry.registerClass(Projection.className, Projection);

package/src/vcs/vcm/util/style/declarativeStyleItem.js

@@ -14,6 +14,7 @@ import {
   whiteColor,
 } from './styleHelpers.js';
 import { originalFeatureSymbol } from '../../layer/vectorSymbols.js';
+import { VcsClassRegistry } from '../../classRegistry.js';
 
 /**
  * @typedef {Object} DeclarativeStyleItemConditions
@@ -558,6 +559,7 @@ class DeclarativeStyleItem extends StyleItem {
 }
 
 export default DeclarativeStyleItem;
+VcsClassRegistry.registerClass(DeclarativeStyleItem.className, DeclarativeStyleItem);
 
 /**
  * @type {DeclarativeStyleItem}

package/src/vcs/vcm/util/style/styleFactory.js

@@ -13,7 +13,7 @@ function getLogger() {
 
 /**
  * @param {(Reference|DeclarativeStyleItemOptions|VectorStyleItemOptions|StyleItem|string)=} styleOptions
- * @param {(VectorStyleItem|DeclarativeStyleItem)=} defaultStyle
+ * @param {StyleItem=} defaultStyle
  * @returns {StyleItem}
  */
 // eslint-disable-next-line import/prefer-default-export

package/src/vcs/vcm/util/style/styleItem.js

@@ -4,6 +4,7 @@ import deepEqual from 'fast-deep-equal';
 import { parseEnumValue } from '@vcsuite/parsers';
 import VcsObject from '../../object.js';
 import VcsEvent from '../../event/vcsEvent.js';
+import { VcsClassRegistry } from '../../classRegistry.js';
 
 /**
  * @namespace style
@@ -241,3 +242,4 @@ class StyleItem extends VcsObject {
 }
 
 export default StyleItem;
+VcsClassRegistry.registerClass(StyleItem.className, StyleItem);

package/src/vcs/vcm/util/style/vectorStyleItem.js

@@ -24,6 +24,7 @@ import {
   getDefaultVectorStyleItemOptions,
 } from './styleHelpers.js';
 import { getShapeFromOptions } from './shapesCategory.js';
+import { VcsClassRegistry } from '../../classRegistry.js';
 
 /**
  * @typedef {Object} VectorStyleItemPattern
@@ -907,6 +908,7 @@ export default VectorStyleItem;
  * @export
  */
 export const defaultVectorStyle = new VectorStyleItem(getDefaultVectorStyleItemOptions());
+VcsClassRegistry.registerClass(VectorStyleItem.className, VectorStyleItem);
 
 /**
  * @param {import("@vcmap/cesium").Color} cesiumColor

package/src/vcs/vcm/util/viewpoint.js

@@ -3,6 +3,7 @@ import { parseBoolean, parseNumber } from '@vcsuite/parsers';
 import Projection, { wgs84Projection } from './projection.js';
 import VcsObject from '../object.js';
 import Extent from './extent.js';
+import { VcsClassRegistry } from '../classRegistry.js';
 
 /**
  * compares two numeric properties
@@ -331,3 +332,5 @@ class ViewPoint extends VcsObject {
 }
 
 export default ViewPoint;
+
+VcsClassRegistry.registerClass(ViewPoint.className, ViewPoint);

package/src/vcs/vcm/vcsApp.js

@@ -0,0 +1,360 @@
+import { getLogger as getLoggerByName } from '@vcsuite/logger';
+import { v4 as uuidv4 } from 'uuid';
+import { check } from '@vcsuite/check';
+import Context from './context.js';
+import {
+  contextIdSymbol,
+  destroyCollection,
+  getObjectFromOptions,
+  deserializeViewPoint,
+  deserializeMap,
+  getLayerIndex,
+  serializeLayer,
+} from './vcsAppContextHelpers.js';
+import makeOverrideCollection from './util/overrideCollection.js';
+import CategoryCollection from './category/categoryCollection.js';
+import MapCollection from './util/mapCollection.js';
+import VcsMap from './maps/map.js';
+import Layer from './layer/layer.js';
+import Collection from './util/collection.js';
+import ObliqueCollection from './oblique/ObliqueCollection.js';
+import ViewPoint from './util/viewpoint.js';
+import StyleItem from './util/style/styleItem.js';
+import IndexedCollection from './util/indexedCollection.js';
+import VcsEvent from './event/vcsEvent.js';
+import { setDefaultProjectionOptions } from './util/projection.js';
+
+/**
+ * @returns {import("@vcsuite/logger").Logger}
+ */
+function getLogger() {
+  return getLoggerByName('init');
+}
+
+/**
+ * @type {Map<string, VcsApp>}
+ */
+const vcsApps = new Map();
+
+/**
+ * @class
+ */
+class VcsApp {
+  constructor() {
+    /**
+     * @type {string}
+     * @private
+     */
+    this._id = uuidv4();
+    /**
+     * @type {Context}
+     * @private
+     */
+    this._defaultDynamicContext = new Context({ id: '_defaultDynamicContext' });
+    /**
+     * @type {Context}
+     * @private
+     */
+    this._dynamicContext = this._defaultDynamicContext;
+
+    const getDynamicContextId = () => this._dynamicContext.id;
+    /**
+     * @type {OverrideMapCollection}
+     * @private
+     */
+    // @ts-ignore
+    this._maps = makeOverrideCollection(
+      new MapCollection(),
+      getDynamicContextId,
+      null,
+      deserializeMap.bind(null, this),
+      VcsMap,
+    );
+    /**
+     * @type {OverrideLayerCollection}
+     * @private
+     */
+    // @ts-ignore
+    this._layers = makeOverrideCollection(
+      this._maps.layerCollection,
+      getDynamicContextId,
+      serializeLayer.bind(null, this),
+      getObjectFromOptions,
+      Layer,
+      getLayerIndex,
+    );
+    /**
+     * @type {OverrideCollection<import("@vcmap/core").ObliqueCollection>}
+     * @private
+     */
+    this._obliqueCollections = makeOverrideCollection(
+      new Collection(),
+      getDynamicContextId,
+      null,
+      getObjectFromOptions,
+      ObliqueCollection,
+    ); // XXX there is a global for this collection in core.
+    /**
+     * @type {OverrideCollection<import("@vcmap/core").ViewPoint>}
+     * @private
+     */
+    this._viewPoints = makeOverrideCollection(
+      new Collection(),
+      getDynamicContextId,
+      null,
+      deserializeViewPoint,
+      ViewPoint,
+    );
+    /**
+     * @type {OverrideCollection<import("@vcmap/core").StyleItem>}
+     * @private
+     */
+    this._styles = makeOverrideCollection(
+      new Collection(),
+      getDynamicContextId,
+      null,
+      getObjectFromOptions,
+      StyleItem,
+    ); // XXX there is a global for this collection in core.
+
+    /**
+     * @type {IndexedCollection<Context>}
+     * @private
+     */
+    this._contexts = new IndexedCollection('id');
+    this._contexts.add(this._dynamicContext);
+    /**
+     * @type {CategoryCollection}
+     * @private
+     */
+    this._categories = new CategoryCollection(this);
+    /**
+     * @type {import("@vcmap/core").VcsEvent<void>}
+     * @private
+     */
+    this._destroyed = new VcsEvent();
+    /**
+     * @type {Promise<void>}
+     * @private
+     */
+    this._contextMutationPromise = Promise.resolve();
+    vcsApps.set(this._id, this);
+  }
+
+  /**
+   * @type {string}
+   * @readonly
+   */
+  get id() { return this._id; }
+
+  /**
+   * @type {OverrideMapCollection}
+   * @readonly
+   */
+  get maps() { return this._maps; }
+
+  /**
+   * @type {OverrideLayerCollection}
+   * @readonly
+   */
+  get layers() { return this._layers; }
+
+  /**
+   * @type {OverrideCollection<import("@vcmap/core").ObliqueCollection>}
+   * @readonly
+   */
+  get obliqueCollections() { return this._obliqueCollections; }
+
+  /**
+   * @type {OverrideCollection<import("@vcmap/core").ViewPoint>}
+   * @readonly
+   */
+  get viewPoints() { return this._viewPoints; }
+
+  /**
+   * @type {OverrideCollection<import("@vcmap/core").StyleItem>}
+   * @readonly
+   */
+  get styles() { return this._styles; }
+
+  /**
+   * @type {CategoryCollection}
+   * @readonly
+   */
+  get categories() { return this._categories; }
+
+  /**
+   * @type {VcsEvent<void>}
+   * @readonly
+   */
+  get destroyed() { return this._destroyed; }
+
+  /**
+   * @returns {VcsEvent<Context>}
+   * @readonly
+   */
+  get contextAdded() { return this._contexts.added; }
+
+  /**
+   * @returns {VcsEvent<Context>}
+   * @readonly
+   */
+  get contextRemoved() { return this._contexts.removed; }
+
+  get dynamicContextId() { return this._dynamicContext.id; }
+
+  /**
+   * @param {string} id
+   * @returns {Context}
+   */
+  getContextById(id) {
+    return this._contexts.getByKey(id);
+  }
+
+  /**
+   * @param {Context} context
+   * @returns {Promise<void>}
+   * @protected
+   */
+  async _parseContext(context) {
+    const { config } = context;
+    if (config.projection) { // XXX this needs fixing. this should be _projections_ and there should be a `defaultProjection`
+      setDefaultProjectionOptions(config.projection);
+    }
+
+    await this._styles.parseItems(config.styles, context.id);
+    await this._layers.parseItems(config.layers, context.id);
+    // TODO add flights & ade here
+
+    await this._obliqueCollections.parseItems(config.obliqueCollections, context.id);
+    await this._viewPoints.parseItems(config.viewpoints, context.id);
+    await this._maps.parseItems(config.maps, context.id);
+
+    if (Array.isArray(config.categories)) {
+      await Promise.all((config.categories).map(async ({ name, items }) => {
+        await this._categories.parseCategoryItems(name, items, context.id);
+      }));
+    }
+  }
+
+  /**
+   * @param {Context} context
+   * @returns {Promise<void>}
+   * @protected
+   */
+  async _setContextState(context) {
+    const { config } = context;
+    [...this._layers]
+      .filter(l => l[contextIdSymbol] === context.id)
+      .forEach((l) => {
+        if (l.activeOnStartup) {
+          l.activate()
+            .catch((err) => {
+              getLogger().error(`Failed to activate active on startup layer ${l.name}`);
+              getLogger().error(err);
+              this._layers.remove(l);
+              l.destroy();
+            });
+        }
+      });
+
+    if (config.startingMapName) {
+      await this._maps.setActiveMap(config.startingMapName);
+    } else if (!this._maps.activeMap && this._maps.size > 0) {
+      await this._maps.setActiveMap([...this._maps][0].name);
+    }
+
+    if (config.startingViewPointName && this._maps.activeMap) {
+      const startViewPoint = this._viewPoints.getByKey(config.startingViewPointName);
+      if (startViewPoint) {
+        await this._maps.activeMap.gotoViewPoint(startViewPoint);
+      }
+    }
+  }
+
+  /**
+   * @param {Context} context
+   * @returns {Promise<void>}
+   */
+  addContext(context) {
+    check(context, Context);
+
+    this._contextMutationPromise = this._contextMutationPromise
+      .then(async () => {
+        if (this._contexts.has(context)) {
+          getLogger().info(`context with id ${context.id} already loaded`);
+          return;
+        }
+
+        await this._parseContext(context);
+        await this._setContextState(context);
+        this._contexts.add(context);
+      });
+    return this._contextMutationPromise;
+  }
+
+  /**
+   * @param {string} contextId
+   * @returns {Promise<void>}
+   * @protected
+   */
+  async _removeContext(contextId) {
+    await Promise.all([
+      this._maps.removeContext(contextId),
+      this._layers.removeContext(contextId),
+      this._viewPoints.removeContext(contextId),
+      this._styles.removeContext(contextId),
+      this._obliqueCollections.removeContext(contextId),
+    ]);
+  }
+
+  /**
+   * @param {string} contextId
+   * @returns {Promise<void>}
+   */
+  removeContext(contextId) {
+    this._contextMutationPromise = this._contextMutationPromise
+      .then(async () => {
+        const context = this._contexts.getByKey(contextId);
+        if (!context) {
+          getLogger().info(`context with id ${contextId} has alread been removed`);
+          return;
+        }
+        await this._removeContext(contextId);
+        this._contexts.remove(context);
+      });
+
+    return this._contextMutationPromise;
+  }
+
+  destroy() {
+    Object.defineProperty(this, '_contextMutationPromise', {
+      get() {
+        throw new Error('VcsApp was destroyed');
+      },
+    });
+    vcsApps.delete(this._id);
+    destroyCollection(this._maps);
+    destroyCollection(this._layers);
+    destroyCollection(this._obliqueCollections);
+    destroyCollection(this._viewPoints);
+    destroyCollection(this._styles);
+    destroyCollection(this._contexts);
+    destroyCollection(this._categories);
+    this.destroyed.raiseEvent();
+    this.destroyed.destroy();
+  }
+}
+
+/**
+ * @param {string} id
+ * @returns {VcsApp}
+ */
+export function getVcsAppById(id) {
+  return vcsApps.get(id);
+}
+
+window.vcs = window.vcs || {};
+window.vcs.apps = vcsApps;
+
+export default VcsApp;

package/src/vcs/vcm/vcsAppContextHelpers.js

@@ -0,0 +1,108 @@
+import { getLogger as getLoggerByName } from '@vcsuite/logger';
+import { VcsClassRegistry } from './classRegistry.js';
+
+/**
+ * @returns {import("@vcsuite/logger").Logger}
+ */
+function getLogger() {
+  return getLoggerByName('init');
+}
+
+/**
+ * @type {symbol}
+ */
+export const contextIdSymbol = Symbol('contextId');
+
+/**
+ * returns a constructor of a type.
+ * @api stable
+ * @export
+ * @param {Object} options
+ * @param {...*} args
+ * @returns {Promise<Object|null>}
+ */
+export async function getObjectFromOptions(options, ...args) {
+  if (!options.type) {
+    getLogger().warning(`ObjectCreation failed: could not find type in options ${options}`);
+    return null;
+  }
+  const ObjectConstructor = await VcsClassRegistry.getClass(options.type);
+  if (!ObjectConstructor) {
+    getLogger().warning(`ObjectCreation failed: could not find javascript class of type ${options.type}`);
+    return null;
+  }
+  let object;
+  try {
+    object = new ObjectConstructor(options, ...args);
+  } catch (ex) {
+    getLogger().warning(`Error: ${ex}`);
+  }
+
+  if (!object) {
+    getLogger().warning('ObjectCreation failed: could not create new Object');
+    return null;
+  }
+  return object;
+}
+
+/**
+ * @param {import("@vcmap/core").VcsApp} vcsApp
+ * @param {VcsMapOptions} mapConfig
+ * @returns {Promise<import("@vcmap/core").VcsMap|null>}
+ */
+export async function deserializeMap(vcsApp, mapConfig) {
+  const map = await getObjectFromOptions(mapConfig);
+  if (map) {
+    map.layerCollection = vcsApp.layers;
+  }
+  return map;
+}
+
+/**
+ * @param {ViewPointOptions} viewPointObject
+ * @returns {Promise<null|import("@vcmap/core").ViewPoint>}
+ */
+export async function deserializeViewPoint(viewPointObject) {
+  const viewpoint = /** @type {import("@vcmap/core").ViewPoint} */ (await getObjectFromOptions(viewPointObject));
+  if (viewpoint && viewpoint.isValid()) {
+    return viewpoint;
+  }
+  getLogger().warning(`Viewpoint ${viewPointObject.name} is not valid`);
+  return null;
+}
+
+/**
+ * @param {import("@vcmap/core").VcsApp} vcsApp
+ * @param {import("@vcmap/core").Layer} layer
+ * @returns {Promise<LayerOptions|null>}
+ */
+export async function serializeLayer(vcsApp, layer) {
+  const serializedLayer = layer.toJSON();
+  serializedLayer.zIndex = layer[vcsApp.layers.zIndexSymbol];
+  return serializedLayer;
+}
+
+/**
+ * @param {import("@vcmap/core").Layer} current
+ * @param {import("@vcmap/core").Layer} previous
+ * @param {number} currentIndex
+ * @returns {number|null}
+ */
+export function getLayerIndex(current, previous, currentIndex) {
+  if (current.zIndex !== previous.zIndex) {
+    return null;
+  }
+  return currentIndex;
+}
+
+/**
+ * @param {import("@vcmap/core").Collection<*>} collection
+ */
+export function destroyCollection(collection) {
+  [...collection].forEach((i) => {
+    if (i.destroy && !i.isDestroyed) {
+      i.destroy();
+    }
+  });
+  collection.destroy();
+}