@vcmap/core 6.3.0-rc.1 → 6.3.0-rc.2

package/src/featureProvider/abstractFeatureProvider.ts

@@ -1,12 +1,14 @@
 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 {
+  defaultVectorStyle,
+  type VectorStyleItemOptions,
+} from '../style/vectorStyleItem.js';
 import VectorProperties, {
   type VectorPropertiesOptions,
 } from '../layer/vectorProperties.js';
@@ -14,20 +16,22 @@ import { isProvidedFeature } from './featureProviderSymbols.js';
 import type StyleItem from '../style/styleItem.js';
 import { type StyleItemOptions } from '../style/styleItem.js';
 import type VcsMap from '../map/vcsMap.js';
+import type { DeclarativeStyleItemOptions } from '../style/declarativeStyleItem.js';
+import type Layer from '../layer/layer.js';
 
 export type AbstractFeatureProviderOptions = VcsObjectOptions & {
   /**
    * the style to apply to features created by this feature provider
    */
-  style?: StyleItemOptions | StyleItem;
+  style?:
+    | StyleItemOptions
+    | VectorStyleItemOptions
+    | DeclarativeStyleItemOptions
+    | 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
    */
@@ -38,7 +42,7 @@ export type AbstractFeatureProviderOptions = VcsObjectOptions & {
  * 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 {
+abstract class AbstractFeatureProvider extends VcsObject {
   static get className(): string {
     return 'AbstractFeatureProvider';
   }
@@ -48,26 +52,15 @@ class AbstractFeatureProvider extends VcsObject {
       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
    */
@@ -78,21 +71,14 @@ class AbstractFeatureProvider extends VcsObject {
    */
   mapTypes: string[];
 
-  constructor(layerName: string, options: AbstractFeatureProviderOptions) {
+  constructor(options: AbstractFeatureProviderOptions) {
     const defaultOptions = AbstractFeatureProvider.getDefaultOptions();
     super({ ...defaultOptions, ...options });
 
-    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
@@ -120,14 +106,14 @@ class AbstractFeatureProvider extends VcsObject {
    * 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 {
+  getProviderFeature(feature: Feature, layer: Layer): Feature {
     if (!feature.getId()) {
       feature.setId(uuidv4());
     }
     if (this.style) {
       feature.setStyle(this.style.style);
     }
-    feature[vcsLayerName] = this.layerName;
+    feature[vcsLayerName] = layer.name;
     feature[isProvidedFeature] = true;
     Object.entries(this.vectorProperties.getValues()).forEach(
       ([key, value]) => {
@@ -146,19 +132,13 @@ class AbstractFeatureProvider extends VcsObject {
    * 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
-   * @param headers - headers optional request headers to be sent with the server request
+   * @param layer - the layer to request the features for
    */
-  // eslint-disable-next-line class-methods-use-this
-  getFeaturesByCoordinate(
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    _coordinate: Coordinate,
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    _resolution: number,
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    _headers?: Record<string, string>,
-  ): Promise<Feature[]> {
-    return Promise.resolve([]);
-  }
+  abstract getFeaturesByCoordinate(
+    coordinate: Coordinate,
+    resolution: number,
+    layer: Layer,
+  ): Promise<Feature[]>;
 
   /**
    * Returns the object required to configure this feature provider.
@@ -168,12 +148,6 @@ class AbstractFeatureProvider extends VcsObject {
   ): AbstractFeatureProviderOptions {
     const config: AbstractFeatureProviderOptions = super.toJSON(defaultOptions);
 
-    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();
     }
@@ -182,9 +156,15 @@ class AbstractFeatureProvider extends VcsObject {
       ...VectorProperties.getDefaultOptions(),
       ...(defaultOptions.vectorProperties as VectorPropertiesOptions),
     });
+
     if (Object.keys(vectorPropertiesConfig).length > 0) {
       config.vectorProperties = vectorPropertiesConfig;
     }
+
+    if (this.mapTypes.length > 0) {
+      config.mapTypes = this.mapTypes.slice();
+    }
+
     return config;
   }
 

package/src/featureProvider/compositeFeatureProvider.ts

@@ -0,0 +1,103 @@
+import type Feature from 'ol/Feature.js';
+import type { Extent } from 'ol/extent.js';
+import type { AbstractFeatureProviderOptions } from './abstractFeatureProvider.js';
+import AbstractFeatureProvider from './abstractFeatureProvider.js';
+import AbstractAttributeProvider, {
+  type AbstractAttributeProviderOptions,
+  type AttributeProvider,
+} from './abstractAttributeProvider.js';
+import type { EventFeature } from '../interaction/abstractInteraction.js';
+import type Layer from '../layer/layer.js';
+import { getProviderForOption } from './featureProviderFactory.js';
+
+export type CompositeFeatureProviderOptions = AbstractFeatureProviderOptions & {
+  featureProviders: (
+    | AbstractFeatureProviderOptions
+    | AbstractFeatureProvider
+  )[];
+  attributeProviders: (
+    | AbstractAttributeProviderOptions
+    | AbstractAttributeProvider
+  )[];
+};
+
+/**
+ * A feature provider that combines multiple feature providers and attribute providers.
+ * Used to combine multiple feature & attribute providers for a layer.
+ * The order of providers is important, as attributes are applied and
+ * features are returned in the order.
+ */
+export default class CompositeFeatureProvider
+  extends AbstractFeatureProvider
+  implements AttributeProvider
+{
+  static get className(): string {
+    return 'CompositeFeatureProvider';
+  }
+
+  private _attributeProviders: AttributeProvider[];
+
+  private _featureProviders: AbstractFeatureProvider[];
+
+  constructor(options: CompositeFeatureProviderOptions) {
+    super(options);
+    this._featureProviders = options.featureProviders
+      .map(getProviderForOption)
+      .filter((fp) => fp instanceof AbstractFeatureProvider);
+
+    this._featureProviders.forEach((fp) => {
+      fp.mapTypes = this.mapTypes;
+    });
+
+    this._attributeProviders = options.attributeProviders
+      .map(getProviderForOption)
+      .filter((ap) => ap instanceof AbstractAttributeProvider);
+  }
+
+  async augmentFeatures(
+    features: EventFeature[],
+    extent?: Extent,
+  ): Promise<void> {
+    for (const provider of this._attributeProviders) {
+      // order is relevant. second provider can overwrite or use attributes of first provider.
+      // eslint-disable-next-line no-await-in-loop
+      await provider.augmentFeatures(features, extent);
+    }
+  }
+
+  async getFeaturesByCoordinate(
+    coordinate: [number, number],
+    resolution: number,
+    layer: Layer,
+  ): Promise<Feature[]> {
+    const featureArray = await Promise.all(
+      this._featureProviders.map((fp) =>
+        fp.getFeaturesByCoordinate(coordinate, resolution, layer),
+      ),
+    );
+
+    return featureArray.flat();
+  }
+
+  async augmentFeature(feature: EventFeature): Promise<void> {
+    for (const provider of this._attributeProviders) {
+      // order is relevant. second provider can overwrite or use attributes of first provider.
+      // eslint-disable-next-line no-await-in-loop
+      await provider.augmentFeature(feature);
+    }
+  }
+
+  toJSON(
+    defaultOptions: AbstractFeatureProviderOptions = AbstractFeatureProvider.getDefaultOptions(),
+  ): CompositeFeatureProviderOptions {
+    const config: Partial<CompositeFeatureProviderOptions> = super.toJSON(
+      defaultOptions,
+    );
+
+    config.featureProviders = this._featureProviders.map((fp) => fp.toJSON());
+    config.attributeProviders = this._attributeProviders.map((ap) =>
+      ap.toJSON(),
+    );
+    return config as CompositeFeatureProviderOptions;
+  }
+}

package/src/featureProvider/csvAttributeProvider.ts

@@ -0,0 +1,186 @@
+import AbstractAttributeProvider, {
+  type AbstractAttributeProviderOptions,
+} from './abstractAttributeProvider.js';
+import { featureProviderClassRegistry } from '../classRegistry.js';
+import { getInitForUrl } from '../util/fetch.js';
+
+export type CsvAttributeProviderOptions = AbstractAttributeProviderOptions & {
+  /**
+   * CSV data as a string or URL to fetch the CSV data from
+   */
+  data: string;
+  /**
+   * Delimiter used in the CSV data (default: ",")
+   */
+  delimiter?: string;
+  /**
+   * Column name to use as the feature ID (default: "id")
+   */
+  idColumn?: string;
+  /**
+   * Optional array of headers, if the data does not contain a header row. If not provided, the first row of the CSV data will be used as headers.
+   */
+  headers?: string[] | null;
+  httpHeaders?: Record<string, string>;
+};
+
+export default class CsvAttributeProvider extends AbstractAttributeProvider {
+  static get className(): string {
+    return 'CsvAttributeProvider';
+  }
+
+  static getDefaultOptions(): Required<CsvAttributeProviderOptions> {
+    return {
+      name: '',
+      keyProperty: '',
+      properties: {},
+      type: CsvAttributeProvider.className,
+      data: '',
+      delimiter: ',',
+      idColumn: 'id',
+      headers: null,
+      httpHeaders: {},
+    };
+  }
+
+  private _urlOrData: string;
+
+  private _data?: Map<string, Record<string, unknown>>;
+
+  private _delimiter: string;
+
+  private _idColumn: string;
+
+  private _headers?: string[];
+
+  private _httpHeaders?: Record<string, string>;
+
+  private _dataLoadingPromise?: Promise<void>;
+
+  constructor(options: CsvAttributeProviderOptions) {
+    const defaultOptions = CsvAttributeProvider.getDefaultOptions();
+    super({ ...defaultOptions, ...options });
+    this._urlOrData = options.data;
+    this._delimiter = options.delimiter ?? defaultOptions.delimiter;
+    this._idColumn = options.idColumn ?? defaultOptions.idColumn;
+
+    if (Array.isArray(options.headers)) {
+      this._headers = options.headers.slice();
+    }
+    if (options.httpHeaders) {
+      this._httpHeaders = structuredClone(options.httpHeaders);
+    }
+  }
+
+  private _readLine(line: string): string[] {
+    return line.split(this._delimiter).map((v) => v.trim());
+  }
+
+  private async _loadData(): Promise<void> {
+    if (this._data) {
+      return;
+    }
+
+    let csvData: string;
+    // Check if URL contains newline - if so, it's the data itself
+    if (this._urlOrData.includes('\n')) {
+      csvData = this._urlOrData;
+    } else {
+      const init = getInitForUrl(this._urlOrData, this._httpHeaders);
+      const response = await fetch(this._urlOrData, init);
+      if (!response.ok) {
+        throw new Error(`Failed to fetch CSV data from ${this._urlOrData}`);
+      }
+      csvData = await response.text();
+    }
+
+    // Split by both Windows (\r\n) and Unix (\n) line endings
+    const lines = csvData.split(/\r?\n/).filter((line) => line.trim() !== '');
+    if (lines.length === 0) {
+      this.getLogger().warning('No CSV data available to load.');
+      this._data = new Map<string, Record<string, unknown>>();
+      return;
+    }
+
+    const dataMap = new Map<string, Record<string, unknown>>();
+
+    let startIndex = 0;
+
+    if (!this._headers) {
+      this._headers = this._readLine(lines[0]);
+      startIndex = 1;
+    }
+
+    for (let i = startIndex; i < lines.length; i++) {
+      const values = this._readLine(lines[i]);
+
+      const attributes: Record<string, unknown> = {};
+
+      for (let j = 0; j < values.length; j++) {
+        const key = this._headers[j] ?? `column_${j}`;
+        attributes[key] = values[j];
+      }
+
+      const id = attributes[this._idColumn];
+      if (typeof id === 'string') {
+        dataMap.set(id, attributes);
+      }
+    }
+
+    this._data = dataMap;
+  }
+
+  private _ensureDataLoaded(): Promise<void> {
+    if (!this._dataLoadingPromise) {
+      this._dataLoadingPromise = this._loadData();
+    }
+    return this._dataLoadingPromise;
+  }
+
+  protected async _getAttributes(
+    key: string,
+  ): Promise<Record<string, unknown> | undefined> {
+    await this._ensureDataLoaded();
+    return this._data?.get(key);
+  }
+
+  protected async _getBulkAttributes(
+    bulk: {
+      key: string;
+    }[],
+  ): Promise<(Record<string, unknown> | undefined)[]> {
+    await this._ensureDataLoaded();
+    return bulk.map(({ key }) => this._data?.get(key));
+  }
+
+  toJSON(
+    defaultOptions = CsvAttributeProvider.getDefaultOptions(),
+  ): CsvAttributeProviderOptions {
+    const config = super.toJSON(defaultOptions) as CsvAttributeProviderOptions;
+    config.data = this._urlOrData;
+    if (this._delimiter !== defaultOptions.delimiter) {
+      config.delimiter = this._delimiter;
+    }
+    if (this._idColumn !== defaultOptions.idColumn) {
+      config.idColumn = this._idColumn;
+    }
+    if (this._headers && this._headers.length > 0) {
+      config.headers = this._headers.slice();
+    }
+    if (this._httpHeaders) {
+      config.httpHeaders = structuredClone(this._httpHeaders);
+    }
+    return config;
+  }
+
+  destroy(): void {
+    this._data?.clear();
+    this._data = undefined;
+    super.destroy();
+  }
+}
+
+featureProviderClassRegistry.registerClass(
+  CsvAttributeProvider.className,
+  CsvAttributeProvider,
+);

package/src/featureProvider/featureProviderFactory.ts

@@ -0,0 +1,31 @@
+import AbstractFeatureProvider, {
+  type AbstractFeatureProviderOptions,
+} from './abstractFeatureProvider.js';
+import AbstractAttributeProvider, {
+  type AbstractAttributeProviderOptions,
+} from './abstractAttributeProvider.js';
+import { featureProviderClassRegistry } from '../classRegistry.js';
+
+export function getProviderForOption(
+  options?:
+    | AbstractFeatureProviderOptions
+    | AbstractAttributeProviderOptions
+    | AbstractAttributeProvider
+    | AbstractFeatureProvider,
+): AbstractFeatureProvider | AbstractAttributeProvider | undefined {
+  if (
+    options instanceof AbstractFeatureProvider ||
+    options instanceof AbstractAttributeProvider
+  ) {
+    return options;
+  }
+
+  if (options?.type) {
+    const CTOR = featureProviderClassRegistry.getClass(options.type);
+    if (CTOR) {
+      return new CTOR(options);
+    }
+  }
+
+  return undefined;
+}

package/src/featureProvider/i3sAttributeProvider.ts

@@ -0,0 +1,60 @@
+import { getLogger } from '@vcsuite/logger';
+import type { I3SNode } from '@vcmap-cesium/engine';
+import { Cesium3DTileFeature } from '@vcmap-cesium/engine';
+import Feature from 'ol/Feature.js';
+import { isI3SFeature } from '../interaction/featureAtPixelInteraction.js';
+import AbstractAttributeProvider from './abstractAttributeProvider.js';
+import { isProvidedFeature } from './featureProviderSymbols.js';
+import { i3sData } from '../layer/layerSymbols.js';
+
+export default class I3SAttributeProvider extends AbstractAttributeProvider {
+  static get className(): string {
+    return 'I3SAttributeProvider';
+  }
+
+  protected async _getAttributes(
+    _key: string,
+    feature: Cesium3DTileFeature | Feature,
+  ): Promise<Record<string, unknown> | undefined> {
+    if (feature instanceof Cesium3DTileFeature) {
+      const id = feature.featureId;
+
+      if (id && feature.content?.tile?.i3sNode) {
+        const node = feature.content.tile.i3sNode as unknown as I3SNode;
+        return node
+          .loadFields()
+          .then(() => node.getFieldsForFeature(id) as Record<string, unknown>)
+          .catch(() => {
+            getLogger(this.className).warning(
+              `Error getting I3S fields for feature with id ${id}`,
+            );
+            return undefined;
+          });
+      }
+    } else if (
+      feature instanceof Feature &&
+      feature[isProvidedFeature] &&
+      isI3SFeature(feature)
+    ) {
+      const { i3sNode, cartesianPosition } = feature[i3sData];
+      if (i3sNode && cartesianPosition) {
+        return i3sNode
+          .loadFields()
+          .then(
+            () =>
+              i3sNode.getFieldsForPickedPosition(cartesianPosition) as Record<
+                string,
+                unknown
+              >,
+          )
+          .catch(() => {
+            getLogger(this.className).warning(
+              'Error getting I3S fields for picked position',
+            );
+            return undefined;
+          });
+      }
+    }
+    return undefined;
+  }
+}

package/src/featureProvider/jsonAttributeProvider.ts

@@ -0,0 +1,109 @@
+import { is, oneOf } from '@vcsuite/check';
+import AbstractAttributeProvider, {
+  type AbstractAttributeProviderOptions,
+} from './abstractAttributeProvider.js';
+import { getInitForUrl, requestJson } from '../util/fetch.js';
+
+export type JsonAttributeData = {
+  features: { id: string | number; properties: Record<string, unknown> }[];
+};
+
+export type JsonAttributeProviderOptions = AbstractAttributeProviderOptions & {
+  data: string | JsonAttributeData;
+  headers?: Record<string, string>;
+};
+
+export default class JsonAttributeProvider extends AbstractAttributeProvider {
+  static get className(): string {
+    return 'JsonAttributeProvider';
+  }
+
+  static getDefaultOptions(): JsonAttributeProviderOptions {
+    return {
+      ...AbstractAttributeProvider.getDefaultOptions(),
+      data: '',
+    };
+  }
+
+  private _data?: Map<string, Record<string, unknown>>;
+
+  private readonly _dataOrUrl: string | JsonAttributeData;
+
+  private readonly _headers?: Record<string, string>;
+
+  constructor(options: JsonAttributeProviderOptions) {
+    super(options);
+
+    this._dataOrUrl = is(options.data, Object)
+      ? structuredClone(options.data)
+      : options.data;
+    this._headers = options.headers;
+  }
+
+  private async _loadData(): Promise<void> {
+    if (this._data) {
+      return;
+    }
+
+    let serializedData;
+    if (is(this._dataOrUrl, String)) {
+      const init = getInitForUrl(this._dataOrUrl, this._headers);
+      serializedData = await requestJson<JsonAttributeData>(
+        this._dataOrUrl,
+        init,
+      );
+    } else {
+      serializedData = this._dataOrUrl;
+    }
+
+    const data = new Map<string, Record<string, unknown>>();
+    if (Array.isArray(serializedData.features)) {
+      serializedData?.features?.forEach(({ id, properties }) => {
+        if (is(id, oneOf(String, Number)) && is(properties, Object)) {
+          data.set(String(id), properties);
+        }
+      });
+    }
+
+    this._data = data;
+  }
+
+  protected async _getAttributes(
+    key: string,
+  ): Promise<Record<string, unknown> | undefined> {
+    await this._loadData();
+    return this._data?.get(key);
+  }
+
+  protected async _getBulkAttributes(
+    bulk: {
+      key: string;
+    }[],
+  ): Promise<(Record<string, unknown> | undefined)[]> {
+    await this._loadData();
+    return bulk.map(({ key }) => this._data?.get(key));
+  }
+
+  toJSON(
+    defaultOptions = JsonAttributeProvider.getDefaultOptions(),
+  ): JsonAttributeProviderOptions {
+    const config = super.toJSON(defaultOptions) as JsonAttributeProviderOptions;
+    if (is(this._dataOrUrl, Object)) {
+      config.data = structuredClone(this._dataOrUrl);
+    } else {
+      config.data = this._dataOrUrl;
+    }
+
+    if (this._headers) {
+      config.headers = structuredClone(this._headers);
+    }
+
+    return config;
+  }
+
+  destroy(): void {
+    this._data?.clear();
+    this._data = undefined;
+    super.destroy();
+  }
+}