@vcmap/core 5.0.0-rc.9 → 5.0.1

package/src/classRegistry.ts

@@ -0,0 +1,147 @@
+import { is, check } from '@vcsuite/check';
+import { getLogger, type Logger } from '@vcsuite/logger';
+import OverrideClassRegistry from './overrideClassRegistry.js';
+import type Layer from './layer/layer.js';
+import type VcsMap from './map/vcsMap.js';
+import type StyleItem from './style/styleItem.js';
+import type Category from './category/category.js';
+import type AbstractFeatureProvider from './featureProvider/abstractFeatureProvider.js';
+import type TileProvider from './layer/tileProvider/tileProvider.js';
+
+function logger(): Logger {
+  return getLogger('ClassRegistry');
+}
+
+export type Ctor<T extends new (...args: any) => any> = new (
+  ...params: any
+) => InstanceType<T>;
+
+export type TypedConstructorOptions = { type?: string } & Record<
+  string,
+  unknown
+>;
+
+class ClassRegistry<T extends Ctor<T>> {
+  private _classMap: Map<string, Ctor<T>>;
+
+  constructor() {
+    this._classMap = new Map();
+  }
+
+  getClassNames(): string[] {
+    return [...this._classMap.keys()];
+  }
+
+  /**
+   * Register a class by its class name.
+   * @param  className
+   * @param  ctor
+   */
+  registerClass(className: string, ctor: Ctor<T>): void {
+    check(className, String);
+    check(ctor, Function);
+
+    if (this._classMap.has(className)) {
+      throw new Error(
+        'a constructor with this className has already been registered',
+      );
+    }
+
+    this._classMap.set(className, ctor);
+  }
+
+  /**
+   * Gets the constructor for a registered class or undefined, if no such class was registerd
+   */
+  getClass(className: string): Ctor<T> | undefined {
+    check(className, String);
+
+    if (this._classMap.has(className)) {
+      return this._classMap.get(className);
+    }
+    return undefined;
+  }
+
+  hasClass(className: string): boolean {
+    check(className, String);
+
+    return this._classMap.has(className);
+  }
+
+  create(className: string, ...args: unknown[]): InstanceType<T> | undefined {
+    check(className, String);
+
+    const Ctor = this.getClass(className);
+    if (!Ctor) {
+      logger().error(`could not find constructor ${className}`);
+      return undefined;
+    }
+    return new Ctor(...args);
+  }
+
+  createFromTypeOptions(
+    options: TypedConstructorOptions,
+    ...args: unknown[]
+  ): InstanceType<T> | undefined {
+    check(options, { type: String });
+
+    return this.create(options.type as string, options, ...args);
+  }
+}
+
+export default ClassRegistry;
+
+export const layerClassRegistry: ClassRegistry<typeof Layer> =
+  new ClassRegistry();
+
+export const tileProviderClassRegistry: ClassRegistry<typeof TileProvider> =
+  new ClassRegistry();
+
+export const featureProviderClassRegistry: ClassRegistry<
+  typeof AbstractFeatureProvider
+> = new ClassRegistry();
+
+export const mapClassRegistry: ClassRegistry<typeof VcsMap> =
+  new ClassRegistry();
+
+export const styleClassRegistry: ClassRegistry<typeof StyleItem> =
+  new ClassRegistry();
+
+export const categoryClassRegistry: ClassRegistry<typeof Category> =
+  new ClassRegistry();
+
+/**
+ * Returns an object based on a class registry or override class registry and a typed options object. as opposed to ClassRegistry.createFromTypedOptions, this function never throws.
+ */
+export function getObjectFromClassRegistry<T extends Ctor<T>>(
+  classRegistry: OverrideClassRegistry<T> | ClassRegistry<T>,
+  options: TypedConstructorOptions,
+  ...args: unknown[]
+): InstanceType<T> | null {
+  // move to classReg
+  if (!is(classRegistry, [ClassRegistry, OverrideClassRegistry])) {
+    logger().error(
+      `ObjectCreation failed: no class registry provided for ${String(
+        options.type,
+      )}`,
+    );
+    return null;
+  }
+
+  if (!options?.type) {
+    logger().warning('ObjectCreation failed: could not find type in options');
+    return null;
+  }
+  let object;
+  try {
+    object = classRegistry.createFromTypeOptions(options, ...args);
+  } catch (ex) {
+    logger().warning(`Error: ${String(ex)}`);
+  }
+
+  if (!object) {
+    logger().warning('ObjectCreation failed: could not create new Object');
+    return null;
+  }
+  return object as InstanceType<T>;
+}

package/src/featureProvider/abstractFeatureProvider.ts

@@ -0,0 +1,191 @@
+import { v4 as uuidv4 } from 'uuid';
+import { parseBoolean } from '@vcsuite/parsers';
+import type { Feature } from 'ol/index.js';
+import type { Coordinate } from 'ol/coordinate.js';
+
+import { vcsLayerName } from '../layer/layerSymbols.js';
+import VcsObject, { type VcsObjectOptions } from '../vcsObject.js';
+import { getStyleOrDefaultStyle } from '../style/styleFactory.js';
+import { defaultVectorStyle } from '../style/vectorStyleItem.js';
+import VectorProperties, {
+  type VectorPropertiesOptions,
+} from '../layer/vectorProperties.js';
+import { isProvidedFeature } from './featureProviderSymbols.js';
+import StyleItem, { type StyleItemOptions } from '../style/styleItem.js';
+import type VcsMap from '../map/vcsMap.js';
+
+export type AbstractFeatureProviderOptions = VcsObjectOptions & {
+  /**
+   * the style to apply to features created by this feature provider
+   */
+  style?: StyleItemOptions | StyleItem;
+  /**
+   * the vector properties of the features. Allow picking is false by default.
+   */
+  vectorProperties?: VectorProperties | VectorPropertiesOptions;
+  /**
+   * show the resulting geometry in the map
+   */
+  showGeometry?: boolean;
+  /**
+   * can be used to constrict the featureProvider to specific mapTypes empty array means no restriction
+   */
+  mapTypes?: string[];
+};
+
+/**
+ * An abstract class providing features for {@link Layer}s which cannot provide features directly, but can provide features for
+ * a given location, e.g. WmsLayer with a getFeatureInfo configuration. In this case, a feature provider can be created for this layer.
+ */
+class AbstractFeatureProvider extends VcsObject {
+  static get className(): string {
+    return 'AbstractFeatureProvider';
+  }
+
+  static getDefaultOptions(): AbstractFeatureProviderOptions {
+    return {
+      vectorProperties: {
+        allowPicking: false,
+      },
+      showGeometry: false,
+      mapTypes: [],
+    };
+  }
+
+  /**
+   * The layer name of the associated layer
+   */
+  layerName: string;
+
+  /**
+   * The style set on features created by this provider
+   */
+  style: StyleItem | undefined;
+
+  /**
+   * Whether to show the geometry on selection.
+   */
+  showGeometry: boolean;
+
+  /**
+   * The vector properties assigned to features created by this provider
+   */
+  vectorProperties: VectorProperties;
+
+  /**
+   * Map ClassNames Can be used to only apply this featureProvider to the specified maps
+   */
+  mapTypes: string[];
+
+  constructor(layerName: string, options: AbstractFeatureProviderOptions) {
+    super(options);
+    const defaultOptions = AbstractFeatureProvider.getDefaultOptions();
+
+    this.layerName = layerName;
+
+    this.style = options.style
+      ? getStyleOrDefaultStyle(options.style, defaultVectorStyle.clone())
+      : undefined;
+
+    this.showGeometry = parseBoolean(
+      options.showGeometry,
+      defaultOptions.showGeometry,
+    );
+
+    this.vectorProperties =
+      options.vectorProperties instanceof VectorProperties
+        ? options.vectorProperties
+        : new VectorProperties({
+            ...defaultOptions.vectorProperties,
+            ...options.vectorProperties,
+          });
+
+    this.mapTypes = Array.isArray(options.mapTypes)
+      ? options.mapTypes
+      : (defaultOptions.mapTypes as string[]);
+  }
+
+  /**
+   * checks if the featureProvider is supported for provided Map
+   */
+  isSupported(map: VcsMap): boolean {
+    return (
+      map &&
+      (this.mapTypes.length === 0 || this.mapTypes.includes(map.className))
+    );
+  }
+
+  /**
+   * Ensures the feature has an ID, applies all vectorProperties and adds style and the vcsLayerName
+   * and isProvidedFeature symbols to the feature
+   */
+  getProviderFeature(feature: Feature): Feature {
+    if (!feature.getId()) {
+      feature.setId(uuidv4());
+    }
+    if (this.style) {
+      feature.setStyle(this.style.style);
+    }
+    feature[vcsLayerName] = this.layerName;
+    feature[isProvidedFeature] = true;
+    Object.entries(this.vectorProperties.getValues()).forEach(
+      ([key, value]) => {
+        const olcsKey = `olcs_${key}`;
+        if (feature.get(olcsKey) === undefined && value !== undefined) {
+          feature.set(olcsKey, value);
+        }
+      },
+    );
+    return feature;
+  }
+
+  /**
+   * This method must be overwritten by any implementations. Before returning the array of features, be sure to use the getProviderFeature
+   * on each feature to ensure all properties and symbols required by the VCM architecture
+   * to handle your feature is called: (e.g. <code>return features.map(f => this.getProviderFeature(f)</code>);
+   * @param coordinate - in mercator
+   * @param resolution - meters per pixel for the given location
+   */
+  // eslint-disable-next-line no-unused-vars,class-methods-use-this
+  getFeaturesByCoordinate(
+    _coordinate: Coordinate,
+    _resolution: number,
+  ): Promise<Feature[]> {
+    return Promise.resolve([]);
+  }
+
+  /**
+   * Returns the object required to configure this feature provider.
+   */
+  toJSON(): AbstractFeatureProviderOptions {
+    const config: AbstractFeatureProviderOptions = super.toJSON();
+
+    const defaultOptions = AbstractFeatureProvider.getDefaultOptions();
+    delete config.name; // the name is irrelevant, since its the layers name
+
+    if (this.showGeometry !== defaultOptions.showGeometry) {
+      config.showGeometry = this.showGeometry;
+    }
+
+    if (this.style) {
+      config.style = this.style.toJSON();
+    }
+
+    const vectorPropertiesConfig = this.vectorProperties.getVcsMeta({
+      ...VectorProperties.getDefaultOptions(),
+      ...defaultOptions.vectorProperties,
+    });
+    if (Object.keys(vectorPropertiesConfig).length > 0) {
+      config.vectorProperties = vectorPropertiesConfig;
+    }
+    return config;
+  }
+
+  destroy(): void {
+    this.style = undefined;
+    this.vectorProperties.destroy();
+    super.destroy();
+  }
+}
+
+export default AbstractFeatureProvider;

package/src/featureProvider/featureProviderSymbols.ts

@@ -0,0 +1,5 @@
+/**
+ * Added to ol.Feature, if they are not part of a layer, but provided by an {@link AbstractFeatureProvider}.
+ */
+// eslint-disable-next-line import/prefer-default-export
+export const isProvidedFeature: unique symbol = Symbol('isProvidedFeature');

package/src/featureProvider/tileProviderFeatureProvider.ts

@@ -0,0 +1,55 @@
+import type { Coordinate } from 'ol/coordinate.js';
+import type { Feature } from 'ol/index.js';
+import AbstractFeatureProvider, {
+  type AbstractFeatureProviderOptions,
+} from './abstractFeatureProvider.js';
+import { featureProviderClassRegistry } from '../classRegistry.js';
+import type TileProvider from '../layer/tileProvider/tileProvider.js';
+
+export type TileProviderFeatureProviderOptions =
+  AbstractFeatureProviderOptions & {
+    tileProvider: TileProvider;
+  };
+
+class TileProviderFeatureProvider extends AbstractFeatureProvider {
+  static get className(): string {
+    return 'TileProviderFeatureProvider';
+  }
+
+  tileProvider: TileProvider;
+
+  /**
+   * @param  layerName
+   * @param  options
+   */
+  constructor(layerName: string, options: TileProviderFeatureProviderOptions) {
+    super(layerName, options);
+
+    this.mapTypes = ['CesiumMap'];
+    this.tileProvider = options.tileProvider;
+  }
+
+  async getFeaturesByCoordinate(
+    coordinate: Coordinate,
+    resolution: number,
+  ): Promise<Feature[]> {
+    const features = await this.tileProvider.getFeaturesByCoordinate(
+      coordinate,
+      resolution,
+    );
+    return features.filter((feature) => {
+      return this.vectorProperties.getAllowPicking(feature);
+    });
+  }
+
+  destroy(): void {
+    this.tileProvider.destroy();
+    super.destroy();
+  }
+}
+
+export default TileProviderFeatureProvider;
+featureProviderClassRegistry.registerClass(
+  TileProviderFeatureProvider.className,
+  TileProviderFeatureProvider,
+);