@vcmap/core 6.0.0-rc.7 → 6.0.0-rc.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vcmap/core",
-  "version": "6.0.0-rc.7",
+  "version": "6.0.0-rc.9",
   "description": "",
   "main": "dist/index.js",
   "type": "module",
@@ -41,7 +41,7 @@
     "@types/chai": "^4.3.16",
     "@types/geojson": "^7946.0.10",
     "@types/mocha": "^10.0.7",
-    "@types/node": "^20.14.10",
+    "@types/node": "^20.16.5",
     "@types/proj4": "^2.5.5",
     "@types/sinon": "^10.0.15",
     "@types/sinon-chai": "^3.2.12",
@@ -61,8 +61,8 @@
     "resize-observer-polyfill": "^1.5.1",
     "sinon": "^9.2.4",
     "sinon-chai": "^3.6.0",
-    "typedoc": "^0.26.4",
-    "typescript": "^5.0.4"
+    "typedoc": "^0.26.7",
+    "typescript": "^5.6.2"
   },
   "peerDependencies": {
     "@vcmap-cesium/engine": "^11.0.2",
@@ -115,7 +115,7 @@
     "@vcsuite/logger": "^1.0.1",
     "@vcsuite/parsers": "^1.0.3",
     "fast-deep-equal": "^3.1.3",
-    "proj4": "^2.12.0",
+    "proj4": "^2.12.1",
     "rbush": ">=4.0.0",
     "rbush-knn": "^4.0.0",
     "uuid": "^10.0.0"

package/src/category/category.ts

@@ -72,7 +72,8 @@ function checkMergeOptionOverride<
  * the requestCategory API on the categories collection. Do not use toJSON to retrieve the state of a category, since
  * categories outlive modules and may be changed with mergeOptions to no longer reflect your initial state. Requestors
  * should keep track of the requested options themselves.
- * @template {Object|VcsObject} T
+ * @template {Object|VcsObject} T the type of objects in this category
+ * @template {Object} S the serialized state of the object in this category
  * @group Category
  */
 class Category<
@@ -192,7 +193,7 @@ class Category<
       if (feature) {
         feature.setId(String(id));
         setTimeout(() => {
-          this._layer?.addFeatures([feature as Feature]);
+          this._layer?.addFeatures([feature]);
         }, 0); // We need to set a timeout, since removing and adding the feature in the same sync call leads to undefined behavior in OL TODO recheck in ol 6.11
       }
     }

package/src/category/categoryCollection.ts

@@ -118,7 +118,7 @@ class CategoryCollection extends IndexedCollection<Category> {
         options,
       );
       if (category) {
-        if (this.add(category) == null) {
+        if (this.add(category as Category) == null) {
           return null;
         }
       }

package/src/classRegistry.ts

@@ -110,7 +110,7 @@ export const mapClassRegistry: ClassRegistry<typeof VcsMap> =
 export const styleClassRegistry: ClassRegistry<typeof StyleItem> =
   new ClassRegistry();
 
-export const categoryClassRegistry: ClassRegistry<typeof Category> =
+export const categoryClassRegistry: ClassRegistry<typeof Category<any, any>> =
   new ClassRegistry();
 
 /**

package/src/global.d.ts

@@ -1,9 +1,14 @@
 import type VcsApp from './vcsApp.js';
 import { mouseOverSymbol } from './util/editor/editorSymbols.js';
+// eslint-disable-next-line import/no-named-default
+import type { default as VcsModule, VcsModuleConfig } from './vcsModule.js';
 
 declare global {
   interface Window {
-    vcs: { apps: Map<string, VcsApp> };
+    vcs: {
+      apps: Map<string, VcsApp>;
+      createModuleFromConfig: (config: VcsModuleConfig) => VcsModule;
+    };
     opera?: string;
   }
   interface CSSStyleDeclaration {

package/src/layer/cesium/clusterContext.ts

@@ -58,7 +58,7 @@ class ClusterContext implements CesiumVectorContext {
 
         if (instance) {
           removeItem = (): void => {
-            this.entities.remove(instance as Entity);
+            this.entities.remove(instance);
           };
         }
 

package/src/layer/cesium/vectorCesiumImpl.ts

@@ -130,8 +130,8 @@ class VectorCesiumImpl
   private _addFeatures(features: Feature[]): void {
     // TODO we should make this non-blocking to better handle larger data sets check in RIWA Impl
     features.forEach((f) => {
-      this._addFeature(f).catch(() => {
-        this.getLogger().error('failed to convert feature');
+      this._addFeature(f).catch((err) => {
+        this.getLogger().error('failed to convert feature', f, err);
       });
     });
   }

package/src/layer/cesium/vectorContext.ts

@@ -31,6 +31,36 @@ export function setReferenceForPicking(
   primitive.olFeature = feature;
 }
 
+function getIndexOfPrimitive(
+  item: PrimitiveType,
+  collection: PrimitiveCollection,
+): number {
+  const { length } = collection;
+  for (let i = 0; i < length; i++) {
+    const p = collection.get(i) as PrimitiveType;
+    if (p === item) {
+      return i;
+    }
+  }
+  return -1;
+}
+
+function addPrimitiveAtIndex(
+  type: 'scaled' | 'primitive',
+  item: PrimitiveType,
+  collection: PrimitiveCollection,
+  indices: ConvertedIndices,
+): PrimitiveType {
+  let index = indices[type];
+  if (index != null) {
+    if (index > collection.length) {
+      index = undefined;
+    }
+  }
+
+  return collection.add(item, index) as PrimitiveType;
+}
+
 /**
  * Sets splitDirection on primitives. Currently only Model primitives support splitting.
  */
@@ -106,6 +136,10 @@ export interface CesiumVectorContext {
   clear(): void;
 }
 
+type ConvertedItemIndex = { type: 'primitive' | 'scaled'; index: number };
+
+type ConvertedIndices = { primitive?: number; scaled?: number };
+
 export default class VectorContext implements CesiumVectorContext {
   primitives = new PrimitiveCollection();
 
@@ -115,9 +149,13 @@ export default class VectorContext implements CesiumVectorContext {
 
   labels: LabelCollection;
 
-  private _featureItems = new Map<Feature, (() => void)[]>();
+  private _featureItems = new Map<
+    Feature,
+    (() => ConvertedItemIndex | void)[]
+  >();
 
-  private _convertingFeatures: Map<Feature, () => void> = new Map();
+  private _convertingFeatures: Map<Feature, (replace: boolean) => void> =
+    new Map();
 
   splitDirection: SplitDirection;
 
@@ -157,26 +195,63 @@ export default class VectorContext implements CesiumVectorContext {
     feature: Feature,
     allowPicking: boolean,
     items: ConvertedItem[],
+    indices: ConvertedIndices,
   ): void {
     const removeItems = items
       .map((item) => {
         let instance: PrimitiveType | Label | Billboard | undefined;
-        let removeItem: (() => void) | undefined;
+        let removeItem: (() => ConvertedItemIndex | void) | undefined;
         if (item.type === 'primitive') {
           if (item.autoScale) {
-            instance = this.scaledPrimitives.add(item.item) as PrimitiveType;
+            instance = addPrimitiveAtIndex(
+              'scaled',
+              item.item,
+              this.scaledPrimitives,
+              indices,
+            );
+
             if (instance) {
-              removeItem = (): void => {
-                this._scaledDirty.value =
-                  this.scaledPrimitives.remove(instance);
+              removeItem = (): ConvertedItemIndex | undefined => {
+                const currentIndex = getIndexOfPrimitive(
+                  instance as PrimitiveType,
+                  this.scaledPrimitives,
+                );
+                if (currentIndex > -1) {
+                  this._scaledDirty.value =
+                    this.scaledPrimitives.remove(instance);
+
+                  return {
+                    type: 'scaled',
+                    index: currentIndex,
+                  };
+                }
+                return undefined;
               };
               this._scaledDirty.value = true;
             }
           } else {
-            instance = this.primitives.add(item.item) as PrimitiveType;
+            instance = addPrimitiveAtIndex(
+              'primitive',
+              item.item,
+              this.primitives,
+              indices,
+            );
+
             if (instance) {
-              removeItem = (): void => {
-                this.primitives.remove(instance);
+              removeItem = (): ConvertedItemIndex | undefined => {
+                const currentIndex = getIndexOfPrimitive(
+                  instance as PrimitiveType,
+                  this.primitives,
+                );
+
+                if (currentIndex > -1) {
+                  this.primitives.remove(instance);
+                  return {
+                    type: 'primitive',
+                    index: currentIndex,
+                  };
+                }
+                return undefined;
               };
             }
           }
@@ -211,7 +286,7 @@ export default class VectorContext implements CesiumVectorContext {
         }
         return removeItem;
       })
-      .filter((i): i is () => void => i != null);
+      .filter((i) => i != null);
 
     this._featureItems.set(feature, removeItems);
   }
@@ -222,10 +297,15 @@ export default class VectorContext implements CesiumVectorContext {
     vectorProperties: VectorProperties,
     scene: Scene,
   ): Promise<void> {
-    this._convertingFeatures.get(feature)?.();
+    this._convertingFeatures.get(feature)?.(true);
     let deleted = false;
-    this._convertingFeatures.set(feature, () => {
-      deleted = true;
+    let replaced = false;
+    this._convertingFeatures.set(feature, (isReplacement?: boolean) => {
+      if (isReplacement) {
+        replaced = true;
+      } else {
+        deleted = true;
+      }
     });
 
     const convertedItems = await convert(
@@ -235,7 +315,32 @@ export default class VectorContext implements CesiumVectorContext {
       scene,
     );
 
-    this._featureItems.get(feature)?.forEach((removeItem) => removeItem());
+    if (replaced) {
+      convertedItems.forEach((item) => {
+        if (item.type === 'primitive') {
+          item.item.destroy();
+        }
+      });
+      return;
+    }
+
+    const convertedIndices: ConvertedIndices =
+      this._featureItems
+        .get(feature)
+        ?.map((removeItem) => removeItem())
+        ?.filter((i) => i != null)
+        ?.reduce((items, current) => {
+          const minIndex = items[current.type];
+          if (minIndex != null) {
+            items[current.type] =
+              current.index != null && current.index < minIndex
+                ? current.index
+                : items[current.type];
+          } else {
+            items[current.type] = current.index;
+          }
+          return items;
+        }, {} as ConvertedIndices) ?? {};
     this._featureItems.delete(feature);
 
     if (deleted) {
@@ -249,12 +354,13 @@ export default class VectorContext implements CesiumVectorContext {
         feature,
         vectorProperties.getAllowPicking(feature),
         convertedItems,
+        convertedIndices,
       );
     }
   }
 
   removeFeature(feature: Feature): void {
-    this._convertingFeatures.get(feature)?.();
+    this._convertingFeatures.get(feature)?.(false);
     this._convertingFeatures.delete(feature);
     this._featureItems.get(feature)?.forEach((removeItem) => removeItem());
     this._featureItems.delete(feature);
@@ -275,7 +381,7 @@ export default class VectorContext implements CesiumVectorContext {
     this.labels.removeAll();
     this._featureItems.clear();
     this._convertingFeatures.forEach((destroy) => {
-      destroy();
+      destroy(true);
     });
     this._convertingFeatures.clear();
   }
@@ -294,7 +400,7 @@ export default class VectorContext implements CesiumVectorContext {
     // @ts-ignore
     this._rootCollection = null;
     this._convertingFeatures.forEach((destroy) => {
-      destroy();
+      destroy(true);
     });
     this._convertingFeatures.clear();
     this._featureItems.clear();

package/src/layer/tileLoadedHelper.ts

@@ -33,9 +33,7 @@ export async function tiledLayerLoaded(
 ): Promise<void> {
   const impls = layer
     .getImplementations()
-    .filter(
-      (i) => i instanceof CesiumTilesetCesiumImpl,
-    ) as CesiumTilesetCesiumImpl[];
+    .filter((i) => i instanceof CesiumTilesetCesiumImpl);
   if (!layer.active || impls.every((i) => i.cesium3DTileset?.tilesLoaded)) {
     return;
   }

package/src/layer/vectorLayer.ts

@@ -433,9 +433,7 @@ class VectorLayer
    */
   getFeaturesById(ids: (string | number)[]): Feature[] {
     check(ids, [oneOf(String, Number)]);
-    return ids
-      .map((id) => this.getFeatureById(id))
-      .filter((f) => f != null) as Feature[];
+    return ids.map((id) => this.getFeatureById(id)).filter((f) => f != null);
   }
 
   /**

package/src/layer/vectorProperties.ts

@@ -225,7 +225,7 @@ export function parseNearFarScalar(
   if (Array.isArray(value)) {
     const valid = value
       .map((entry) => parseNumber(entry))
-      .filter((entry) => entry != null) as number[];
+      .filter((entry) => entry != null);
     if (valid.length === 4) {
       return new NearFarScalar(valid[0], valid[1], valid[2], valid[3]);
     }
@@ -240,7 +240,7 @@ export function parseCartesian3(
   if (Array.isArray(value)) {
     const valid = value
       .map((entry) => parseNumber(entry))
-      .filter((entry) => entry != null) as number[];
+      .filter((entry) => entry != null);
     if (valid.length === 3) {
       return new Cartesian3(valid[0], valid[1], valid[2]);
     }
@@ -1302,6 +1302,22 @@ class VectorProperties {
       }
     }
 
+    if ('modelOptions' in options) {
+      if (!deepEqual(this._modelOptions, options.modelOptions)) {
+        this._modelOptions = options.modelOptions
+          ? structuredClone(options.modelOptions)
+          : undefined;
+        changedProperties.push('modelOptions');
+      }
+    }
+
+    if ('modelAutoScale' in options) {
+      if (this._modelAutoScale !== options.modelAutoScale) {
+        this._modelAutoScale = !!options.modelAutoScale;
+        changedProperties.push('modelAutoScale');
+      }
+    }
+
     if ('baseUrl' in options) {
       if (options.baseUrl !== this._baseUrl) {
         this._baseUrl = options.baseUrl ?? '';
@@ -1309,6 +1325,15 @@ class VectorProperties {
       }
     }
 
+    if ('primitiveOptions' in options) {
+      if (!deepEqual(this._primitiveOptions, options.primitiveOptions)) {
+        this._primitiveOptions = options.primitiveOptions
+          ? structuredClone(options.primitiveOptions)
+          : undefined;
+        changedProperties.push('primitiveOptions');
+      }
+    }
+
     if (changedProperties.length) {
       this.propertyChanged.raiseEvent(changedProperties);
     }

package/src/ol/geom/geometryCollection.js

@@ -27,26 +27,68 @@ GeometryCollection.prototype.setCoordinates = function setCoordinates(
   );
 };
 
+/**
+ * @type {Record<import("ol/geom/Geometry").GeometryLayout, number>}
+ */
+const layoutScore = {
+  XY: 1,
+  XYM: 2,
+  XYZ: 3,
+  XYZM: 4,
+};
+
+/**
+ * @type {Record<import("ol/geom/Geometry").GeometryLayout, number>}
+ */
+const layoutStride = {
+  XY: 2,
+  XYM: 3,
+  XYZ: 3,
+  XYZM: 4,
+};
+
+/**
+ * @param {import("ol/geom/Geometry").GeometryLayout} layout
+ * @param {import("ol/geom/Geometry").GeometryLayout=} minLayout
+ * @returns { import("ol/geom/Geometry").GeometryLayout}
+ */
+function getMinLayout(layout, minLayout) {
+  if (!minLayout) {
+    return layout;
+  }
+  if (
+    (minLayout === 'XYM' && layout !== 'XYM') ||
+    (layout === 'XYM' && minLayout !== 'XYM')
+  ) {
+    return 'XY';
+  }
+  const inScore = layoutScore[layout];
+  const minScore = layoutScore[minLayout];
+  if (inScore < minScore) {
+    return layout;
+  }
+
+  return minLayout;
+}
+
 /**
  * @returns {import("ol/geom/Geometry").GeometryLayout}
  */
 GeometryCollection.prototype.getLayout = function getLayout() {
-  const firstGeom = this.getGeometriesArray()[0];
-  if (firstGeom) {
-    return firstGeom.getLayout();
-  }
-  return 'XYZ';
+  let maxCommonLayout;
+  this.getGeometriesArrayRecursive().forEach((geom) => {
+    maxCommonLayout = getMinLayout(geom.getLayout(), maxCommonLayout);
+  });
+
+  return maxCommonLayout ?? 'XY';
 };
 
 /**
  * @returns {number}
  */
 GeometryCollection.prototype.getStride = function getStride() {
-  const firstGeom = this.getGeometriesArray()[0];
-  if (firstGeom) {
-    return firstGeom.getStride();
-  }
-  return 2;
+  const layout = this.getLayout();
+  return layoutStride[layout];
 };
 
 /**
@@ -54,7 +96,34 @@ GeometryCollection.prototype.getStride = function getStride() {
  */
 GeometryCollection.prototype.getFlatCoordinates =
   function getFlatCoordinates() {
-    return this.getGeometriesArrayRecursive().flatMap((g) =>
-      g.getFlatCoordinates(),
-    );
+    const commonStride = this.getStride();
+    const flatCoordinates = [];
+    this.getGeometriesArrayRecursive().forEach((geom) => {
+      const geometryStride = geom.getStride();
+      const geometryFlatCoordinates = geom.getFlatCoordinates();
+      if (geometryStride === commonStride) {
+        flatCoordinates.push(geometryFlatCoordinates);
+      } else if (geometryStride > commonStride) {
+        const geometryCoordinateLength = geometryFlatCoordinates.length;
+        const numberOfCoordinates = Math.round(
+          geometryCoordinateLength / geometryStride,
+        );
+        const slicedGeometryCoordinates = new Array(
+          numberOfCoordinates * commonStride,
+        );
+        for (let i = 0; i < geometryCoordinateLength; i += geometryStride) {
+          for (let j = 0; j < commonStride; j++) {
+            const slicedGeometryCoordinateOffset = Math.round(
+              (i / geometryStride) * commonStride,
+            );
+
+            slicedGeometryCoordinates[slicedGeometryCoordinateOffset + j] =
+              geometryFlatCoordinates[i + j];
+          }
+        }
+        flatCoordinates.push(slicedGeometryCoordinates);
+      }
+    });
+
+    return [].concat(...flatCoordinates);
   };

package/src/util/clipping/clippingObject.ts

@@ -166,9 +166,7 @@ class ClippingObject {
         if (layer.active) {
           const visualisations = map.getVisualizationsForLayer(layer);
           const tilesets = visualisations
-            ? ([...visualisations].filter(
-                (v) => v instanceof Cesium3DTileset,
-              ) as Cesium3DTileset[])
+            ? [...visualisations].filter((v) => v instanceof Cesium3DTileset)
             : [];
 
           if (tilesets.length > 0) {

package/src/util/featureconverter/pointHelpers.ts

@@ -257,13 +257,13 @@ function getGeometryInstanceFromOptions(
       : new CylinderGeometry(options.geometryOptions);
   } else if (vectorPropertiesOfType(options, PrimitiveOptionsType.ELLIPSOID)) {
     if (Array.isArray(options.geometryOptions?.radii)) {
-      options.geometryOptions!.radii = Cartesian3.fromArray(
-        options.geometryOptions!.radii,
+      options.geometryOptions.radii = Cartesian3.fromArray(
+        options.geometryOptions.radii,
       );
     }
     if (Array.isArray(options.geometryOptions?.innerRadii)) {
-      options.geometryOptions!.innerRadii = Cartesian3.fromArray(
-        options.geometryOptions!.innerRadii,
+      options.geometryOptions.innerRadii = Cartesian3.fromArray(
+        options.geometryOptions.innerRadii,
       );
     }
     geometry = outline

package/src/util/featureconverter/vectorHeightInfo.ts

@@ -1,4 +1,3 @@
-import { is } from '@vcsuite/check';
 import { Geometry, SimpleGeometry } from 'ol/geom.js';
 import type { Coordinate } from 'ol/coordinate.js';
 import { Cartesian3, HeightReference } from '@vcmap-cesium/engine';
@@ -190,8 +189,8 @@ export function getClampOrigin(geometry: SimpleGeometry): [number, number] {
  * @returns the minimum height
  */
 export function getMinHeight(geometry: Geometry): number {
-  if (!is(geometry, SimpleGeometry) || is2DLayout(geometry.getLayout())) {
-    throw new Error('expected geometry to be a simple YXZ geometry');
+  if (is2DLayout(geometry.getLayout())) {
+    throw new Error('expected geometry to have an YXZ geometry layout');
   }
 
   const stride = geometry.getStride();