@vcmap/core 5.0.0-rc.9 → 5.0.1

package/src/vcsModule.ts

@@ -0,0 +1,127 @@
+import { v4 as uuidv4 } from 'uuid';
+import Projection, { type ProjectionOptions } from './util/projection.js';
+import type { VcsMapOptions } from './map/vcsMap.js';
+import type { LayerOptions } from './layer/layer.js';
+import type { StyleItemOptions } from './style/styleItem.js';
+import type { ViewpointOptions } from './util/viewpoint.js';
+import type { ObliqueCollectionOptions } from './oblique/obliqueCollection.js';
+import type VcsApp from './vcsApp.js';
+import { moduleIdSymbol } from './moduleIdSymbol.js';
+
+export type VcsModuleConfig = {
+  _id?: string | undefined;
+  name?: string | undefined;
+  description?: string | undefined;
+  properties?: Record<string, unknown>;
+  layers?: LayerOptions[];
+  maps?: VcsMapOptions[];
+  styles?: StyleItemOptions[];
+  viewpoints?: ViewpointOptions[];
+  startingViewpointName?: string;
+  startingMapName?: string;
+  startingObliqueCollectionName?: string;
+  projection?: ProjectionOptions;
+  obliqueCollections?: ObliqueCollectionOptions[];
+  categories?: { name: string; items: object[] }[];
+};
+
+/**
+ * The id of the volatile module. Objects with this id shall never be serialized.
+ */
+export const volatileModuleId = uuidv4();
+
+/**
+ * This marks an object as "volatile". This ensures, that an object added to the {@link VcsApp}
+ * will never be serialized into a module, regardless of the current dynamic module. Typical use case is a scratch layer
+ * which represents temporary features.
+ * @param  object - the object to mark as volatile
+ */
+export function markVolatile(
+  object: object & { [moduleIdSymbol]?: string },
+): void {
+  object[moduleIdSymbol] = volatileModuleId;
+}
+
+/**
+ * @group Application
+ */
+class VcsModule {
+  private _uuid: string;
+
+  name: string;
+
+  description: string | undefined;
+
+  properties: Record<string, unknown> | undefined;
+
+  startingViewpointName: string | undefined;
+
+  startingMapName: string | undefined;
+
+  startingObliqueCollectionName: string | undefined;
+
+  projection: Projection | undefined;
+
+  private _config: VcsModuleConfig;
+
+  /**
+   * @param  config
+   */
+  constructor(config: VcsModuleConfig) {
+    this._uuid = config._id || uuidv4();
+    this.name = config.name ?? this._uuid;
+    this.description = config.description;
+    this.properties = config.properties;
+    this.startingViewpointName = config.startingViewpointName;
+    this.startingMapName = config.startingMapName;
+    this.startingObliqueCollectionName = config.startingObliqueCollectionName;
+    this.projection = config.projection
+      ? new Projection(config.projection)
+      : undefined;
+    this._config = config;
+  }
+
+  get _id(): string {
+    return this._uuid;
+  }
+
+  get config(): VcsModuleConfig {
+    return JSON.parse(JSON.stringify(this._config)) as VcsModuleConfig;
+  }
+
+  /**
+   * Sets the config object by serializing all runtime objects of the current app.
+   * @param  app
+   */
+  setConfigFromApp(app: VcsApp): void {
+    this._config = app.serializeModule(this._uuid);
+  }
+
+  toJSON(): VcsModuleConfig {
+    const config: VcsModuleConfig = {};
+    if (this._config._id) {
+      config._id = this._config._id;
+    }
+    if (this.name) {
+      config.name = this.name;
+    }
+    if (this.description != null) {
+      config.description = this.description;
+    }
+    if (this.startingViewpointName != null) {
+      config.startingViewpointName = this.startingViewpointName;
+    }
+    if (this.startingMapName != null) {
+      config.startingMapName = this.startingMapName;
+    }
+    if (this.startingObliqueCollectionName != null) {
+      config.startingObliqueCollectionName = this.startingObliqueCollectionName;
+    }
+    if (this.projection != null) {
+      config.projection = this.projection?.toJSON();
+    }
+    return config;
+  }
+}
+
+export default VcsModule;

package/src/vcsModuleHelpers.ts

@@ -0,0 +1,128 @@
+import { getLogger as getLoggerByName, type Logger } from '@vcsuite/logger';
+import Viewpoint, { type ViewpointOptions } from './util/viewpoint.js';
+import { getObjectFromClassRegistry } from './classRegistry.js';
+// eslint-disable-next-line import/no-named-default
+import type { default as Layer, LayerOptions } from './layer/layer.js';
+// eslint-disable-next-line import/no-named-default
+import type { default as VcsMap, VcsMapOptions } from './map/vcsMap.js';
+import type {
+  // eslint-disable-next-line import/no-named-default
+  default as StyleItem,
+  StyleItemOptions,
+} from './style/styleItem.js';
+import type { TileProviderOptions } from './layer/tileProvider/tileProvider.js';
+import type { AbstractFeatureProviderOptions } from './featureProvider/abstractFeatureProvider.js';
+import type VcsApp from './vcsApp.js';
+
+function getLogger(): Logger {
+  return getLoggerByName('init');
+}
+
+export type ModuleLayerOptions = LayerOptions & {
+  style?: string | StyleItemOptions;
+  tileProvider?: TileProviderOptions;
+  featureProvider?: AbstractFeatureProviderOptions;
+};
+
+export function deserializeMap(
+  vcsApp: VcsApp,
+  mapConfig: VcsMapOptions,
+): VcsMap | null {
+  const map = getObjectFromClassRegistry(vcsApp.mapClassRegistry, mapConfig);
+  if (map) {
+    map.layerCollection = vcsApp.layers;
+  }
+  return map;
+}
+
+export function deserializeViewpoint(
+  viewpointObject: ViewpointOptions,
+): null | Viewpoint {
+  const viewpoint = new Viewpoint(viewpointObject);
+  if (viewpoint && viewpoint.isValid()) {
+    return viewpoint;
+  }
+  getLogger().warning(`Viewpoint ${String(viewpointObject.name)} is not valid`);
+  return null;
+}
+
+export function deserializeLayer(
+  vcsApp: VcsApp,
+  layerConfig: ModuleLayerOptions,
+): Layer | null {
+  let style: StyleItem | undefined | null;
+  if (layerConfig.style) {
+    if (typeof layerConfig.style === 'string') {
+      style = vcsApp.styles.getByKey(layerConfig.style);
+    } else {
+      style = getObjectFromClassRegistry(
+        vcsApp.styleClassRegistry,
+        layerConfig.style,
+      );
+    }
+  } // TODO highlightStyle
+
+  let tileProvider;
+  if (layerConfig.tileProvider) {
+    tileProvider = getObjectFromClassRegistry(
+      vcsApp.tileProviderClassRegistry,
+      layerConfig.tileProvider,
+    );
+  }
+
+  let featureProvider;
+  if (layerConfig.featureProvider) {
+    featureProvider = getObjectFromClassRegistry(
+      vcsApp.featureProviderClassRegistry,
+      layerConfig.featureProvider,
+    );
+  }
+
+  return getObjectFromClassRegistry(vcsApp.layerClassRegistry, {
+    ...layerConfig,
+    style,
+    tileProvider,
+    featureProvider,
+  });
+}
+
+export function serializeLayer(
+  vcsApp: VcsApp,
+  layer: Layer,
+): ModuleLayerOptions {
+  const serializedLayer: ModuleLayerOptions = layer.toJSON();
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  // @ts-ignore
+  serializedLayer.zIndex = layer[vcsApp.layers.zIndexSymbol] as number;
+  if (
+    (serializedLayer?.style as StyleItemOptions)?.name &&
+    vcsApp.styles.hasKey((serializedLayer.style as StyleItemOptions).name)
+  ) {
+    serializedLayer.style = (serializedLayer.style as StyleItemOptions).name;
+  } // TODO highlightStyle
+  return serializedLayer;
+}
+
+export function getLayerIndex(
+  current: Layer,
+  previous?: Layer,
+  currentIndex?: number,
+): number | null | undefined {
+  if (current.zIndex !== previous?.zIndex) {
+    return null;
+  }
+  return currentIndex;
+}
+
+export function destroyCollection(
+  collection: Iterable<{ destroy?: () => void; isDestroyed?: boolean }> & {
+    destroy: () => void;
+  },
+): void {
+  [...collection].forEach((i) => {
+    if (i.destroy && !i.isDestroyed) {
+      i.destroy();
+    }
+  });
+  collection.destroy();
+}

package/src/vcsObject.ts

@@ -0,0 +1,72 @@
+import { v4 as uuidv4 } from 'uuid';
+import { getLogger, type Logger } from '@vcsuite/logger';
+import { moduleIdSymbol } from './moduleIdSymbol.js';
+
+export type VcsObjectOptions = {
+  /**
+   * the type of object, typically only used in configs
+   */
+  type?: string;
+  /**
+   *  name of the object, if not given a uuid is generated, is used for the framework functions getObjectByName
+   */
+  name?: string;
+  /**
+   * key value store for framework independent values per Object
+   */
+  properties?: Record<string, unknown>;
+};
+
+/**
+ * baseclass for all Objects
+ */
+class VcsObject {
+  static get className(): string {
+    return 'VcsObject';
+  }
+
+  /**
+   * unique Name
+   */
+  readonly name: string;
+
+  properties: Record<string, unknown>;
+
+  isDestroyed: boolean;
+
+  [moduleIdSymbol]?: string;
+
+  constructor(options: VcsObjectOptions) {
+    this.name = options.name || uuidv4();
+    this.properties = options.properties || {};
+    this.isDestroyed = false;
+  }
+
+  get className(): string {
+    return (this.constructor as typeof VcsObject).className;
+  }
+
+  getLogger(): Logger {
+    return getLogger(this.className);
+  }
+
+  toJSON(): VcsObjectOptions {
+    const config: VcsObjectOptions = {
+      type: this.className,
+      name: this.name,
+    };
+
+    if (Object.keys(this.properties).length > 0) {
+      config.properties = { ...this.properties };
+    }
+
+    return config;
+  }
+
+  destroy(): void {
+    this.isDestroyed = true;
+    this.properties = {};
+  }
+}
+
+export default VcsObject;