@vcmap/core 5.0.0-rc.9 → 5.0.1

package/src/layer/{geojsonHelpers.js → geojsonHelpers.ts}

@@ -4,79 +4,107 @@ import MultiPolygon from 'ol/geom/MultiPolygon.js';
 import Feature from 'ol/Feature.js';
 import Point from 'ol/geom/Point.js';
 import Circle from 'ol/geom/Circle.js';
+import type GeoJSONFormat from 'ol/format/GeoJSON.js';
+import type { ReadOptions } from 'ol/format/Feature.js';
+import type {
+  FeatureCollection,
+  Feature as GeojsonFeature,
+  Point as GeojsonPoint,
+  Geometry as GeojsonGeometry,
+} from 'geojson';
+import { parseNumber } from '@vcsuite/parsers';
 
 import { getDistance as haversineDistance } from 'ol/sphere.js';
-import Projection, { mercatorProjection, wgs84Projection } from '../util/projection.js';
-import VectorStyleItem, { defaultVectorStyle, vectorStyleSymbol } from '../style/vectorStyleItem.js';
+import Projection, {
+  mercatorProjection,
+  wgs84Projection,
+} from '../util/projection.js';
+import VectorStyleItem, {
+  defaultVectorStyle,
+  VectorStyleItemOptions,
+  vectorStyleSymbol,
+} from '../style/vectorStyleItem.js';
 import { parseColor } from '../style/styleHelpers.js';
-import VectorLayer from './vectorLayer.js';
 import { featureStoreStateSymbol } from './featureStoreLayerState.js';
 import { embedIconsInStyle } from '../style/writeStyle.js';
 import DeclarativeStyleItem from '../style/declarativeStyleItem.js';
-import { vcsMetaVersion } from './layer.js';
+import { VcsMeta, vcsMetaVersion } from './vectorProperties.js';
 import Extent3D from '../util/featureconverter/extent3D.js';
-import { circleFromCenterRadius, enforceEndingVertex, removeEndingVertexFromGeometry } from '../util/geometryHelpers.js';
+import {
+  circleFromCenterRadius,
+  enforceEndingVertex,
+  removeEndingVertexFromGeometry,
+} from '../util/geometryHelpers.js';
+import type StyleItem from '../style/styleItem.js';
+import { alreadyTransformedToMercator } from './vectorSymbols.js';
 
 const featureProjection = 'EPSG:3857';
 
-/**
- * @type {import("ol/format/GeoJSON").default}
- * @private
- */
-let format;
+let format: GeoJSONFormat;
 
-/**
- * @returns {import("ol/format/GeoJSON").default}
- */
-function getFormat() {
+function getFormat(): GeoJSONFormat {
   if (!format) {
     format = new GeoJSON();
   }
   return format;
 }
 
-/**
- * @typedef {Object} GeoJSONData
- * @property {Array<import("ol").Feature<import("ol/geom/Geometry").default>>} features
- * @property {import("@vcmap/core").StyleItem|undefined} style
- * @property {VcsMeta|undefined} vcsMeta
- * @api
- */
-
-/**
- * @typedef {GeoJSONreadOptions} GeoJSONinternalReadOptions
- * @property {import("ol/format/Feature").ReadOptions|undefined} formatOptions
- * @property {Array<string>|undefined} embeddedIcons
- */
-
-/**
- * @typedef {Object} GeoJSONreadOptions
- * @property {Projection|undefined} targetProjection - projection of the output features, if undefined Mercator will be used
- * @property {Projection|undefined} dataProjection - projection of the input dataset if undefined WGS84 will be assumed
- * @property {boolean} [dynamicStyle=false]
- * @property {boolean} [readLegacyStyleOptions=false]
- * @property {boolean} [dontReadStyle=false]
- * @property {VectorStyleItem|undefined} defaultStyle
- */
-
-/**
- * @typedef {Object} GeoJSONwriteOptions
- * @property {boolean} [asObject=false] - whether to write an object or a string
- * @property {boolean} [writeStyle=false] - whether to include vcsStyle options
- * @property {boolean} [writeDefaultStyle=false] - whether to output the default style. if the style of a layer is the default layer it is not written.
- * @property {boolean} [embedIcons=false] - whether to embed custom icons when writing styles, otherwise no style is written for custom icons
- * @property {boolean} [prettyPrint=false] - pretty print the json, if not asObject
- * @property {boolean} [writeId=false] - whether to output the feature ID
- * @api
- */
-
-
-/**
- * @param {Object} geojson
- * @returns {string|null}
- * @export
- */
-export function getEPSGCodeFromGeojson(geojson) {
+type GeoJSONData = {
+  features: Feature[];
+  style?: StyleItem;
+  vcsMeta?: VcsMeta;
+};
+
+type GeoJSONinternalReadOptions = GeoJSONreadOptions & {
+  formatOptions?: ReadOptions;
+  embeddedIcons?: string[];
+};
+
+export type GeoJSONreadOptions = {
+  /**
+   * projection of the output features, if undefined Mercator will be used
+   */
+  targetProjection?: Projection;
+  /**
+   * projection of the input dataset if undefined WGS84 will be assumed
+   */
+  dataProjection?: Projection;
+  dynamicStyle?: boolean;
+  readLegacyStyleOptions?: boolean;
+  dontReadStyle?: boolean;
+  defaultStyle?: VectorStyleItem;
+};
+
+export type GeoJSONwriteOptions = {
+  /**
+   * whether to write an object or a string
+   */
+  asObject?: boolean;
+  /**
+   * whether to include vcsStyle options
+   */
+  writeStyle?: boolean;
+  /**
+   * whether to output the default style. if the style of a layer is the default layer it is not written.
+   */
+  writeDefaultStyle?: boolean;
+  /**
+   * whether to embed custom icons when writing styles, otherwise no style is written for custom icons
+   */
+  embedIcons?: boolean;
+  /**
+   * pretty print the json, if not asObject
+   */
+  prettyPrint?: boolean;
+  /**
+   * whether to output the feature ID
+   */
+  writeId?: boolean;
+};
+
+export function getEPSGCodeFromGeojson(
+  geojson: FeatureCollection,
+): string | null {
   const { crs } = geojson;
   if (crs) {
     if (crs.type === 'name') {
@@ -94,10 +122,9 @@ export function getEPSGCodeFromGeojson(geojson) {
 
 /**
  * updates legacy features to the new olcesium namespaceing olcs_
- * @param {import("ol").Feature<import("ol/geom/Geometry").default>} feature
- * @export
+ * @param  feature
  */
-export function updateLegacyFeature(feature) {
+export function updateLegacyFeature(feature: Feature): void {
   // these changes can be done silently, because the features haven't been added to any layer
   if (feature.get('altitudeMode')) {
     feature.set('olcs_altitudeMode', feature.get('altitudeMode'), true);
@@ -109,7 +136,11 @@ export function updateLegacyFeature(feature) {
     } else {
       const extent = Extent3D.fromGeometry(feature.getGeometry());
       const minHeight = Number.isFinite(extent.minZ) ? extent.minZ : 0;
-      feature.set('olcs_extrudedHeight', feature.get('extrudedHeight') - minHeight, true);
+      feature.set(
+        'olcs_extrudedHeight',
+        feature.get('extrudedHeight') - minHeight,
+        true,
+      );
     }
     feature.unset('extrudedHeight', true);
   }
@@ -123,34 +154,26 @@ export function updateLegacyFeature(feature) {
   }
 }
 
-/**
- * @param {Object} geometryObj
- * @param {GeoJSONinternalReadOptions} options
- * @returns {import("ol").Feature<import("ol/geom/Geometry").default>}
- */
-function readGeometry(geometryObj, options) {
+function readGeometry(
+  geometryObj: GeojsonGeometry,
+  options: GeoJSONinternalReadOptions,
+): Feature {
   const geometry = getFormat().readGeometry(geometryObj, options.formatOptions);
-  if (String(options.formatOptions.featureProjection) === 'EPSG:3857') {
-    geometry[VectorLayer.alreadyTransformedToMercator] = true;
+  if (String(options.formatOptions?.featureProjection) === 'EPSG:3857') {
+    geometry[alreadyTransformedToMercator] = true;
   }
   removeEndingVertexFromGeometry(geometry);
   return new Feature({ geometry });
 }
 
-/**
- * @param {VectorStyleItemOptions} object
- * @param {GeoJSONinternalReadOptions} options
- * @returns {VectorStyleItemOptions}
- * @todo this could also be done for declarative styles image and conditions could be checked?
- */
-function setEmbeddedIcons(object, options) {
-  if (
-    object.image &&
-    object.image.src &&
-    /^:\d+$/.test(object.image.src)
-  ) {
+function setEmbeddedIcons(
+  object: VectorStyleItemOptions,
+  options: GeoJSONinternalReadOptions,
+): VectorStyleItemOptions {
+  if (object.image && object.image.src && /^:\d+$/.test(object.image.src)) {
     if (options.embeddedIcons) {
-      object.image.src = options.embeddedIcons[object.image.src.substring(1)];
+      object.image.src =
+        options.embeddedIcons[Number(object.image.src.substring(1))];
     } else {
       delete object.image.src;
     }
@@ -158,16 +181,16 @@ function setEmbeddedIcons(object, options) {
   return object;
 }
 
-/**
- * @param {Object} properties
- * @param {string} geometryType
- * @returns {VectorStyleItemOptions|undefined}
- */
-function parseLegacyStyleOptions(properties, geometryType) {
-  const color = properties.color ? parseColor(properties.color) : false;
-  const width = properties.width || 1.25;
-  const radius = properties.pointRadius || 5;
-  const opacity = properties.opacity || 0.8;
+function parseLegacyStyleOptions(
+  properties: Record<string, unknown>,
+  geometryType: string,
+): VectorStyleItemOptions | undefined {
+  const color = properties.color
+    ? parseColor(properties.color as string)
+    : false;
+  const width = parseNumber(properties.width, 1.25);
+  const radius = parseNumber(properties.pointRadius, 5);
+  const opacity: number = parseNumber(properties.opacity, 0.8);
 
   delete properties.color;
   delete properties.width;
@@ -178,7 +201,7 @@ function parseLegacyStyleOptions(properties, geometryType) {
     const fillColor = color ? color.slice() : [255, 255, 255, 0.4];
     fillColor[3] = opacity;
     return {
-      fill: { color: /** @type {import("ol/color").Color} */ (fillColor) },
+      fill: { color: fillColor },
       stroke: {
         color: color || parseColor('#3399CC'),
         width,
@@ -209,17 +232,19 @@ function parseLegacyStyleOptions(properties, geometryType) {
   }
   return undefined;
 }
-/**
- * @param {Object} featureObj
- * @param {GeoJSONinternalReadOptions} options
- * @returns {import("ol").Feature<import("ol/geom/Geometry").default>|null}
- */
-function readFeature(featureObj, options) {
+
+function readFeature(
+  featureObj: GeojsonFeature,
+  options: GeoJSONinternalReadOptions,
+): Feature | null {
   if (!featureObj.geometry) {
     return null;
   }
-  const radius = featureObj.geometry.olcs_radius;
-  let geometry = getFormat().readGeometry(featureObj.geometry, options.formatOptions);
+  const radius = (featureObj.geometry as GeojsonPoint).olcs_radius;
+  let geometry = getFormat().readGeometry(
+    featureObj.geometry,
+    options.formatOptions,
+  );
 
   if (featureObj.radius && geometry instanceof Point) {
     const coordinates = geometry.getCoordinates();
@@ -235,17 +260,21 @@ function readFeature(featureObj, options) {
     }
     geometry = circleFromCenterRadius(coordinates, radius);
   }
-  if (String(options.formatOptions.featureProjection) === 'EPSG:3857') {
-    geometry[VectorLayer.alreadyTransformedToMercator] = true;
+  if (String(options.formatOptions?.featureProjection) === 'EPSG:3857') {
+    geometry[alreadyTransformedToMercator] = true;
   }
 
-  featureObj.vcsMeta = featureObj.vcsMeta || {};
-  if (featureObj.vcsStyle) {
-    featureObj.vcsMeta.style = featureObj.vcsMeta.style || featureObj.vcsStyle;
-  }
+  featureObj.vcsMeta = featureObj.vcsMeta || ({} as VcsMeta);
   const { properties } = featureObj;
-  if (options.readLegacyStyleOptions && !featureObj.vcsMeta.style) {
-    featureObj.vcsMeta.style = parseLegacyStyleOptions(properties, geometry.getType());
+  if (
+    properties &&
+    options.readLegacyStyleOptions &&
+    !featureObj.vcsMeta.style
+  ) {
+    featureObj.vcsMeta.style = parseLegacyStyleOptions(
+      properties,
+      geometry.getType(),
+    );
   }
   removeEndingVertexFromGeometry(geometry);
   const feature = new Feature({ ...properties, geometry });
@@ -258,7 +287,10 @@ function readFeature(featureObj, options) {
   }
 
   if (featureObj.vcsMeta.style && !options.dontReadStyle) {
-    featureObj.vcsMeta.style = setEmbeddedIcons(featureObj.vcsMeta.style, options);
+    featureObj.vcsMeta.style = setEmbeddedIcons(
+      featureObj.vcsMeta.style,
+      options,
+    );
     let styleItem;
     if (options.defaultStyle) {
       styleItem = options.defaultStyle
@@ -279,27 +311,29 @@ function readFeature(featureObj, options) {
 
 /**
  * parses a string to GeojsonLayer
- * @param {string|Object} input
- * @param {GeoJSONreadOptions=} readOptions
- * @returns {GeoJSONData}
- * @throws SyntaxError
- * @export
- * @api
  */
-export function parseGeoJSON(input, readOptions = {}) {
-  const geoJSON = typeof input === 'string' ? JSON.parse(input) : input;
-
-  const epsgCode = getEPSGCodeFromGeojson(geoJSON);
-  const defaultDataProjection = epsgCode ? { epsg: epsgCode } : readOptions.dataProjection;
-  /** @type {GeoJSONinternalReadOptions} */
-  const options = {
+export function parseGeoJSON(
+  input: string | FeatureCollection | GeojsonFeature | GeojsonGeometry,
+  readOptions: GeoJSONreadOptions = {},
+): GeoJSONData {
+  const geoJSON = (typeof input === 'string' ? JSON.parse(input) : input) as
+    | FeatureCollection
+    | GeojsonFeature
+    | GeojsonGeometry;
+
+  const epsgCode = getEPSGCodeFromGeojson(geoJSON as FeatureCollection);
+  const defaultDataProjection = epsgCode
+    ? { epsg: epsgCode }
+    : readOptions.dataProjection;
+
+  const options: GeoJSONinternalReadOptions = {
     formatOptions: {
-      dataProjection: defaultDataProjection ?
-        defaultDataProjection.epsg :
-        wgs84Projection.epsg,
-      featureProjection: readOptions.targetProjection ?
-        readOptions.targetProjection.epsg :
-        mercatorProjection.epsg,
+      dataProjection: defaultDataProjection
+        ? defaultDataProjection.epsg
+        : wgs84Projection.epsg,
+      featureProjection: readOptions.targetProjection
+        ? readOptions.targetProjection.epsg
+        : mercatorProjection.epsg,
     },
     dontReadStyle: readOptions.dontReadStyle,
     readLegacyStyleOptions: readOptions.readLegacyStyleOptions,
@@ -311,10 +345,11 @@ export function parseGeoJSON(input, readOptions = {}) {
   }
 
   if (geoJSON.type === 'FeatureCollection') {
-    geoJSON.vcsMeta = geoJSON.vcsMeta || {
-      embeddedIcons: geoJSON.vcsEmbeddedIcons,
-      style: geoJSON.vcsStyle,
-    };
+    geoJSON.vcsMeta =
+      geoJSON.vcsMeta ||
+      ({
+        embeddedIcons: geoJSON.vcsEmbeddedIcons,
+      } as VcsMeta);
 
     let style;
     if (geoJSON.vcsMeta.embeddedIcons) {
@@ -324,21 +359,29 @@ export function parseGeoJSON(input, readOptions = {}) {
       if (geoJSON.vcsMeta.style.type === DeclarativeStyleItem.className) {
         style = new DeclarativeStyleItem(geoJSON.vcsMeta.style);
       } else {
-        geoJSON.vcsMeta.style = setEmbeddedIcons(geoJSON.vcsMeta.style, options);
-        options.defaultStyle = options.defaultStyle
+        geoJSON.vcsMeta.style = setEmbeddedIcons(
+          geoJSON.vcsMeta.style,
+          options,
+        );
+        options.defaultStyle = (options.defaultStyle ?? defaultVectorStyle)
           .clone()
           .assign(new VectorStyleItem(geoJSON.vcsMeta.style));
         style = options.defaultStyle;
       }
     }
     return {
-      features: geoJSON.features.map(f => readFeature(f, options)).filter(f => f),
+      features: geoJSON.features
+        .map((f) => readFeature(f, options))
+        .filter((f) => f) as Feature[],
       style: geoJSON.vcsMeta.style ? style : undefined,
       vcsMeta: geoJSON.vcsMeta ? geoJSON.vcsMeta : undefined,
     };
   } else if (geoJSON.type === 'Feature') {
     const feature = readFeature(geoJSON, options);
-    return { features: feature ? [feature] : [], vcsMeta: geoJSON.vcsMeta ? geoJSON.vcsMeta : undefined };
+    return {
+      features: feature ? [feature] : [],
+      vcsMeta: geoJSON.vcsMeta ? geoJSON.vcsMeta : undefined,
+    };
   } else if (geoJSON.type != null) {
     return { features: [readGeometry(geoJSON, options)] };
   }
@@ -346,26 +389,19 @@ export function parseGeoJSON(input, readOptions = {}) {
 }
 
 /**
- * @param {import("ol").Feature<import("ol/geom/Geometry").default>} feature
- * @param {GeoJSONwriteOptions=} options
- * @param {Array=} embeddedIcons
- * @returns {Object}
+ * @param  feature
+ * @param  options
+ * @param  embeddedIcons
  */
-export function writeGeoJSONFeature(feature, options = {}, embeddedIcons) {
-  const featureObject = {
-    type: 'Feature',
-    properties: feature.getProperties(),
-  };
-
-  if (options.writeId) {
-    featureObject.id = feature.getId();
-  }
-
-  delete featureObject.properties[feature.getGeometryName()];
-  delete featureObject.properties.style;
-  delete featureObject.properties.olcs_allowPicking;
-
+export function writeGeoJSONFeature(
+  feature: Feature,
+  options: GeoJSONwriteOptions = {},
+  embeddedIcons: string[] = [],
+): GeojsonFeature {
   let geometry = feature.getGeometry();
+  if (!geometry) {
+    throw new Error('Cannot write geometry less feature to geojson');
+  }
   let radius = null;
   if (geometry instanceof Circle) {
     const coordinates = geometry.getCoordinates();
@@ -376,26 +412,47 @@ export function writeGeoJSONFeature(feature, options = {}, embeddedIcons) {
     geometry = new Point(geometry.getCenter());
   } else if (geometry instanceof Polygon) {
     const coordinates = geometry.getCoordinates();
-    coordinates.forEach((ring) => { enforceEndingVertex(ring); });
+    coordinates.forEach((ring) => {
+      enforceEndingVertex(ring);
+    });
     geometry.setCoordinates(coordinates);
   } else if (geometry instanceof MultiPolygon) {
     const coordinates = geometry.getCoordinates();
     coordinates.forEach((poly) => {
-      poly.forEach((ring) => { enforceEndingVertex(ring); });
+      poly.forEach((ring) => {
+        enforceEndingVertex(ring);
+      });
     });
     geometry.setCoordinates(coordinates);
   }
 
-  featureObject.geometry = getFormat().writeGeometryObject(geometry, {
+  const geojsonGeometry = getFormat().writeGeometryObject(geometry, {
     featureProjection,
     rightHanded: true,
   });
 
+  const properties = feature.getProperties();
+  delete properties[feature.getGeometryName()];
+  delete properties.style;
+  delete properties.olcs_allowPicking;
+
+  const featureObject: GeojsonFeature = {
+    type: 'Feature',
+    properties,
+    geometry: geojsonGeometry,
+  };
+
+  if (options.writeId) {
+    featureObject.id = feature.getId();
+  }
+
   if (radius) {
-    featureObject.geometry.olcs_radius = radius;
+    (featureObject.geometry as GeojsonPoint).olcs_radius = radius;
   }
 
-  featureObject.vcsMeta = {};
+  featureObject.vcsMeta = {
+    version: vcsMetaVersion,
+  };
 
   if (options.writeStyle && feature[vectorStyleSymbol]) {
     featureObject.vcsMeta.style = embedIconsInStyle(
@@ -409,20 +466,24 @@ export function writeGeoJSONFeature(feature, options = {}, embeddedIcons) {
 
 /**
  * Writes all the features of the current layer to GeojsonLayer
- * @param {GeoJSONData} data
- * @param {GeoJSONwriteOptions=} options
- * @returns {string|Object}
- * @export
  */
-export function writeGeoJSON(data, options = {}) { // how to handel embedded icons when they are not set on the vcsMeta but options is true?
-  const vcsMeta = data.vcsMeta || {};
+export function writeGeoJSON(
+  data: GeoJSONData,
+  options: GeoJSONwriteOptions = {},
+): string | FeatureCollection {
+  // how to handel embedded icons when they are not set on the vcsMeta but options is true?
+  const vcsMeta = data.vcsMeta || { version: vcsMetaVersion };
   vcsMeta.version = vcsMetaVersion;
-  const featureObjs = data.features.map(feature => writeGeoJSONFeature(feature, options, vcsMeta.embeddedIcons));
-  const obj = {
+  const featureObjs = data.features.map((feature) =>
+    writeGeoJSONFeature(feature, options, vcsMeta.embeddedIcons),
+  );
+  const obj: FeatureCollection = {
     type: 'FeatureCollection',
     features: featureObjs,
     vcsMeta,
   };
 
-  return options.asObject ? obj : JSON.stringify(obj, null, options.prettyPrint ? 2 : null);
+  return options.asObject
+    ? obj
+    : JSON.stringify(obj, undefined, options.prettyPrint ? 2 : undefined);
 }