@vcmap/core 5.0.0-rc.4 → 5.0.0-rc.7

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

@@ -0,0 +1,224 @@
+/* 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 '../event/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/vcs/vcm/util/projection.js

@@ -14,9 +14,12 @@ import { VcsClassRegistry } from '../classRegistry.js';
  * @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 = getTransform('EPSG:4326', 'EPSG:3857');
-export const mercatorToWgs84Transformer = getTransform('EPSG:3857', 'EPSG:4326');
+export const wgs84ToMercatorTransformer = /** @type {CorrectTransformFunction} */ (getTransform('EPSG:4326', 'EPSG:3857'));
+export const mercatorToWgs84Transformer = /** @type {CorrectTransformFunction} */ (getTransform('EPSG:3857', 'EPSG:4326'));
 
 
 /**

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/vcsApp.js

@@ -0,0 +1,373 @@
+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';
+import Oblique from './maps/oblique.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,
+      config => new ObliqueCollection(config),
+      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();
+            });
+        }
+      });
+
+    const activeObliqueCollection = [...this._obliqueCollections]
+      .find(c => c[contextIdSymbol] === context.id && c.activeOnStartup);
+
+    if (activeObliqueCollection) {
+      [...this._maps]
+        .filter(m => m instanceof Oblique)
+        .forEach((m) => { /** @type {Oblique} */ (m).setCollection(activeObliqueCollection); });
+    }
+
+    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;
+  }
+
+  /**
+   * Destroys the app and all its collections, their content and ui managers.
+   */
+  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;