@vcmap/core 6.0.0-rc.6 → 6.0.0-rc.8

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]);
     }
@@ -897,10 +897,10 @@ class VectorProperties {
   }
 
   /**
-   * Get the features or the properties modelOptions. Returns an empty Object if both are undefined
+   * Get the features or the properties modelOptions.
    * @param  feature
    */
-  getModelOptions(feature: Feature): Record<string, unknown> {
+  getModelOptions(feature: Feature): Record<string, unknown> | undefined {
     const featureValue = feature.get('olcs_modelOptions') as
       | Record<string, unknown>
       | undefined;
@@ -910,7 +910,7 @@ class VectorProperties {
     if (this.modelOptions) {
       return this.modelOptions;
     }
-    return {};
+    return undefined;
   }
 
   get modelAutoScale(): boolean {
@@ -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,13 +1325,22 @@ 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);
     }
   }
 
   getValues(): VectorPropertiesOptions {
-    const values = {
+    return {
       altitudeMode: getAltitudeModeOptions(this.altitudeMode),
       allowPicking: this.allowPicking,
       classificationType: getClassificationTypeOptions(this.classificationType),
@@ -1336,9 +1361,11 @@ class VectorProperties {
       modelHeading: this.modelHeading,
       modelPitch: this.modelPitch,
       modelRoll: this.modelRoll,
+      modelAutoScale: this.modelAutoScale,
+      modelOptions: this.modelOptions,
       baseUrl: this.baseUrl,
+      primitiveOptions: this.primitiveOptions,
     };
-    return values;
   }
 
   /**

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,5 +96,34 @@ GeometryCollection.prototype.getStride = function getStride() {
  */
 GeometryCollection.prototype.getFlatCoordinates =
   function getFlatCoordinates() {
-    return this.getGeometriesArray().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/clipping/clippingPlaneHelper.ts

@@ -13,7 +13,6 @@ import {
   type Camera,
 } from '@vcmap-cesium/engine';
 import type { Coordinate } from 'ol/coordinate.js';
-import type { Geometry } from 'ol/geom.js';
 import Feature from 'ol/Feature.js';
 import LineString from 'ol/geom/LineString.js';
 import { offset } from 'ol/sphere.js';
@@ -27,7 +26,7 @@ import Extent3D from '../featureconverter/extent3D.js';
 import {
   enforceEndingVertex,
   enforceRightHand,
-  getFlatCoordinatesFromGeometry,
+  getFlatCoordinateReferences,
 } from '../geometryHelpers.js';
 import { mercatorToCartesian } from '../math.js';
 
@@ -162,7 +161,7 @@ export function createClippingPlaneCollection(
   check(transformMatrix, optional(Matrix4));
 
   const clippingPlanes = [];
-  const geometry = feature.getGeometry() as Geometry;
+  const geometry = feature.getGeometry()!;
   const geometryType = geometry.getType();
 
   if (geometryType === 'Point') {
@@ -174,7 +173,7 @@ export function createClippingPlaneCollection(
       ),
     );
   } else {
-    const coords = getFlatCoordinatesFromGeometry(geometry);
+    const coords = getFlatCoordinateReferences(geometry);
     if (
       coords.length < 2 ||
       (coords[0][0] === coords[1][0] && coords[0][1] === coords[1][1])

package/src/util/editor/editorHelpers.ts

@@ -18,7 +18,7 @@ import {
 } from '@vcmap-cesium/engine';
 
 import { mercatorToCartesian } from '../math.js';
-import { getFlatCoordinatesFromGeometry } from '../geometryHelpers.js';
+import { getFlatCoordinateReferences } from '../geometryHelpers.js';
 import CesiumMap from '../../map/cesiumMap.js';
 import { vertexIndexSymbol, vertexSymbol } from './editorSymbols.js';
 import {
@@ -365,7 +365,7 @@ export async function drapeGeometryOnTerrain(
 ): Promise<void> {
   if (map instanceof CesiumMap) {
     const coordinates = geometry.getCoordinates() as any[];
-    const flats = getFlatCoordinatesFromGeometry(geometry, coordinates);
+    const flats = getFlatCoordinateReferences(geometry, coordinates);
     await map.getHeightFromTerrain(flats);
     geometry.setCoordinates(coordinates, 'XYZ');
   }
@@ -382,7 +382,7 @@ export async function placeGeometryOnTerrain(
 ): Promise<void> {
   if (map instanceof CesiumMap) {
     const coordinates = geometry.getCoordinates() as any[];
-    const flats = getFlatCoordinatesFromGeometry(geometry, coordinates);
+    const flats = getFlatCoordinateReferences(geometry, coordinates);
     await map.getHeightFromTerrain(flats);
     let minHeight = Infinity;
     flats.forEach((coord) => {

package/src/util/featureconverter/convert.ts

@@ -109,7 +109,9 @@ export function getStylesArray(
   return styles;
 }
 
-function getSingleGeometriesFromGeometry(geometry: Geometry): SingleGeometry[] {
+export function getSingleGeometriesFromGeometry(
+  geometry: Geometry,
+): SingleGeometry[] {
   if (
     geometry instanceof Point ||
     geometry instanceof Polygon ||

package/src/util/featureconverter/pointHelpers.ts

@@ -44,6 +44,7 @@ import {
   RelativeHeightReference,
   VectorHeightInfo,
 } from './vectorHeightInfo.js';
+import { scaleSymbol } from '../../layer/cesium/vectorContext.js';
 
 function makeOffsetAutoScalePrimitive(
   primitive: Primitive | Model,
@@ -114,12 +115,16 @@ function makeClampedPrimitive(
       undefined,
       scratchUpdateHeightCartesian,
     );
-
-    const geometryModelMatrix = Matrix4.fromScale(scale);
+    let usedScale = scale;
+    const autoScale = primitive[scaleSymbol];
+    if (autoScale != null) {
+      usedScale = new Cartesian3(autoScale, autoScale, autoScale);
+    }
+    const geometryModelMatrix = Matrix4.fromScale(usedScale);
     if (offset) {
       Matrix4.setTranslation(
         geometryModelMatrix,
-        Cartesian3.multiplyComponents(offset, scale, new Cartesian3()),
+        Cartesian3.multiplyComponents(offset, usedScale, new Cartesian3()),
         geometryModelMatrix,
       );
     }
@@ -131,7 +136,7 @@ function makeClampedPrimitive(
     primitive.modelMatrix = Matrix4.multiply(
       transform,
       geometryModelMatrix,
-      new Matrix4(),
+      primitive.modelMatrix,
     );
   };
 
@@ -252,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();

package/src/util/geometryHelpers.ts

@@ -19,8 +19,18 @@ import {
   Polygon,
   SimpleGeometry,
 } from 'ol/geom.js';
+import { Feature } from 'ol';
 import Projection from './projection.js';
 import { mercatorToCartographic } from './math.js';
+import VectorProperties from '../layer/vectorProperties.js';
+import {
+  getHeightInfo,
+  isClampedHeightReference,
+  isRelativeHeightReference,
+  RelativeHeightReference,
+  VectorHeightInfo,
+} from './featureconverter/vectorHeightInfo.js';
+import { getSingleGeometriesFromGeometry } from './featureconverter/convert.js';
 
 export function getFlatCoordinatesFromSimpleGeometry(
   geometry: SimpleGeometry,
@@ -44,7 +54,7 @@ export function getFlatCoordinatesFromSimpleGeometry(
   return [];
 }
 
-export function getFlatCoordinatesFromGeometry(
+export function getFlatCoordinateReferences(
   geometry: Geometry,
   inputCoordinates?: any[],
 ): Coordinate[] {
@@ -78,9 +88,7 @@ export function getFlatCoordinatesFromGeometry(
   } else if (geometry instanceof GeometryCollection) {
     flattenCoordinates = geometry
       .getGeometries()
-      .map((g, i) =>
-        getFlatCoordinatesFromGeometry(g, coordinates?.[i] as any[]),
-      )
+      .map((g, i) => getFlatCoordinateReferences(g, coordinates?.[i] as any[]))
       .reduce((current, next) => current.concat(next));
   }
   return flattenCoordinates as Coordinate[];
@@ -195,7 +203,7 @@ export function from3Dto2DLayout(geometry: Geometry): void {
     return;
   }
   const coordinates = geometry.getCoordinates() as any[];
-  const flatCoordinates = getFlatCoordinatesFromGeometry(geometry, coordinates);
+  const flatCoordinates = getFlatCoordinateReferences(geometry, coordinates);
   flatCoordinates.forEach((coordinate) => {
     if (layout === 'XYZM') {
       coordinate[2] = coordinate.pop()!;
@@ -207,13 +215,13 @@ export function from3Dto2DLayout(geometry: Geometry): void {
 }
 
 /**
- * Wil transform a 2D geometry (layout XY XYM) in place to 3D (XYZ XYZM) using the provided scene & height reference.
- * will no apply anything, if the layout is already 3D
+ * Places a geometry on to the ground (or terrain). The geometry is changed in place. This function
+ * will set the layout to a respective 3D layout.
  * @param geometry
  * @param scene
- * @param heightReference
+ * @param heightReference - clamp to ground will use `scene.getHeightMostDetailed`, terrain will use `sampleTerrainMostDetailed` using the scenes terrain provider
  */
-export async function from2Dto3DLayout(
+export async function placeGeometryOnGround(
   geometry: Geometry,
   scene: Scene,
   heightReference:
@@ -221,17 +229,15 @@ export async function from2Dto3DLayout(
     | HeightReference.CLAMP_TO_TERRAIN,
 ): Promise<void> {
   const layout = geometry.getLayout();
-  if (!is2DLayout(layout)) {
-    return;
-  }
   const coordinates = geometry.getCoordinates() as any[];
-  const flatCoordinates = getFlatCoordinatesFromGeometry(geometry, coordinates);
+  const flatCoordinates = getFlatCoordinateReferences(geometry, coordinates);
   const cartographics = flatCoordinates.map((c) => mercatorToCartographic(c));
   if (heightReference === HeightReference.CLAMP_TO_GROUND) {
     await scene.sampleHeightMostDetailed(cartographics);
   } else {
     await sampleTerrainMostDetailed(scene.terrainProvider, cartographics);
   }
+
   cartographics.forEach((c, index) => {
     if (layout === 'XYM') {
       flatCoordinates[index][3] = flatCoordinates[index][2];
@@ -240,5 +246,151 @@ export async function from2Dto3DLayout(
       flatCoordinates[index][2] = c.height;
     }
   });
-  geometry.setCoordinates(coordinates, layout === 'XYM' ? 'XYZM' : 'XYZ');
+
+  geometry.setCoordinates(
+    coordinates,
+    layout === 'XYM' || layout === 'XYZM' ? 'XYZM' : 'XYZ',
+  );
+}
+
+/**
+ * Wil transform a 2D geometry (layout XY XYM) in place to 3D (XYZ XYZM) using the provided scene & height reference.
+ * will no apply anything, if the layout is already 3D
+ * @param geometry
+ * @param scene
+ * @param heightReference
+ */
+export async function from2Dto3DLayout(
+  geometry: Geometry,
+  scene: Scene,
+  heightReference:
+    | HeightReference.CLAMP_TO_GROUND
+    | HeightReference.CLAMP_TO_TERRAIN,
+): Promise<void> {
+  if (is2DLayout(geometry.getLayout())) {
+    await placeGeometryOnGround(geometry, scene, heightReference);
+  }
+}
+
+function setZCoordinate(geometry: Geometry, z: number): void {
+  const layout = geometry.getLayout();
+  const coordinates = geometry.getCoordinates() as any[];
+  const flatCoordinates = getFlatCoordinateReferences(geometry, coordinates);
+
+  flatCoordinates.forEach((c) => {
+    if (layout === 'XYM') {
+      c[3] = c[2];
+      c[2] = z;
+    } else {
+      c[2] = z;
+    }
+  });
+
+  geometry.setCoordinates(
+    coordinates,
+    layout === 'XYM' || layout === 'XYZM' ? 'XYZM' : 'XYZ',
+  );
+}
+
+export async function createAbsoluteFeature(
+  feature: Feature,
+  vectorProperties: VectorProperties,
+  scene: Scene,
+): Promise<Feature | null> {
+  const clone = feature.clone();
+  const geometry = clone.getGeometry();
+  if (!geometry) {
+    return null;
+  }
+
+  const altitudeMode = vectorProperties.getAltitudeMode(clone);
+  let groundLevel = vectorProperties.getGroundLevel(clone);
+
+  if (altitudeMode === HeightReference.NONE) {
+    if (groundLevel != null) {
+      setZCoordinate(geometry, groundLevel);
+    } else if (is2DLayout(geometry.getLayout())) {
+      await from2Dto3DLayout(geometry, scene, HeightReference.CLAMP_TO_GROUND);
+    }
+  } else if (isClampedHeightReference(altitudeMode)) {
+    if (groundLevel != null) {
+      setZCoordinate(geometry, groundLevel);
+    } else {
+      await placeGeometryOnGround(
+        geometry,
+        scene,
+        altitudeMode !== HeightReference.CLAMP_TO_TERRAIN
+          ? HeightReference.CLAMP_TO_GROUND
+          : HeightReference.CLAMP_TO_TERRAIN,
+      );
+    }
+  } else if (isRelativeHeightReference(altitudeMode)) {
+    const singleGeometries = getSingleGeometriesFromGeometry(geometry);
+    await Promise.all(
+      singleGeometries.map(async (singleGeometry) => {
+        const heightInfo = getHeightInfo(
+          clone,
+          singleGeometry,
+          vectorProperties,
+        ) as VectorHeightInfo<RelativeHeightReference>;
+
+        ({ groundLevel } = heightInfo);
+        if (heightInfo.clampOrigin) {
+          const cartographics = [
+            mercatorToCartographic(heightInfo.clampOrigin),
+          ];
+          if (
+            heightInfo.heightReference === HeightReference.RELATIVE_TO_TERRAIN
+          ) {
+            await sampleTerrainMostDetailed(
+              scene.terrainProvider,
+              cartographics,
+            );
+          } else {
+            await scene.sampleHeightMostDetailed(cartographics);
+          }
+          groundLevel = cartographics[0].height;
+        }
+
+        const coordinates = singleGeometry.getCoordinates() as any[];
+        const flatCoordinates = getFlatCoordinateReferences(
+          singleGeometry,
+          coordinates,
+        );
+        const { heightAboveGround } = heightInfo;
+        const setCoordinate =
+          heightAboveGround == null
+            ? (c: Coordinate): void => {
+                c[2] += groundLevel as number;
+              }
+            : (c: Coordinate): void => {
+                c[2] = (groundLevel as number) + heightAboveGround;
+              };
+        flatCoordinates.forEach(setCoordinate);
+        singleGeometry.setCoordinates(coordinates, 'XYZ');
+      }),
+    );
+
+    if (geometry instanceof MultiPoint) {
+      geometry.setCoordinates(
+        singleGeometries.map((g) => g.getCoordinates() as Coordinate),
+      );
+    } else if (geometry instanceof MultiPolygon) {
+      geometry.setCoordinates(
+        singleGeometries.map((g) => g.getCoordinates() as Coordinate[][]),
+      );
+    } else if (geometry instanceof MultiLineString) {
+      geometry.setCoordinates(
+        singleGeometries.map((g) => g.getCoordinates() as Coordinate[]),
+      );
+    } else if (geometry instanceof GeometryCollection) {
+      geometry.setGeometries(singleGeometries);
+    }
+  }
+
+  clone.set('olcs_altitudeMode', 'absolute');
+  clone.unset('olcs_groundLevel');
+  clone.unset('olcs_heightAboveGround');
+
+  return clone;
 }

package/src/vcsApp.ts

@@ -27,6 +27,7 @@ import { setDefaultProjectionOptions } from './util/projection.js';
 import ObliqueMap from './map/obliqueMap.js';
 import OverrideClassRegistry from './overrideClassRegistry.js';
 import ClassRegistry, {
+  AbstractCtor,
   categoryClassRegistry,
   Ctor,
   featureProviderClassRegistry,
@@ -117,7 +118,9 @@ class VcsApp {
 
   private _flights: OverrideCollection<FlightInstance, FlightCollection>;
 
-  private _categoryClassRegistry: OverrideClassRegistry<typeof Category>;
+  private _categoryClassRegistry: OverrideClassRegistry<
+    typeof Category<any, any>
+  >;
 
   private _categories: CategoryCollection;
 
@@ -347,11 +350,13 @@ class VcsApp {
     return this._styleClassRegistry;
   }
 
-  get categoryClassRegistry(): OverrideClassRegistry<typeof Category> {
+  get categoryClassRegistry(): OverrideClassRegistry<
+    typeof Category<any, any>
+  > {
     return this._categoryClassRegistry;
   }
 
-  get categoryItemClassRegistry(): OverrideClassRegistry<Ctor<any>> {
+  get categoryItemClassRegistry(): OverrideClassRegistry<AbstractCtor> {
     return this._categoryItemClassRegistry;
   }
 
@@ -422,7 +427,7 @@ class VcsApp {
           [...this._maps]
             .filter((m) => m instanceof ObliqueMap)
             .map((m) => {
-              return (m as ObliqueMap).setCollection(startingObliqueCollection);
+              return m.setCollection(startingObliqueCollection);
             }),
         );
       }
@@ -623,5 +628,7 @@ export function getVcsAppById(id: string): VcsApp | undefined {
 
 window.vcs = window.vcs || {};
 window.vcs.apps = vcsApps;
+window.vcs.createModuleFromConfig = (config: VcsModuleConfig): VcsModule =>
+  new VcsModule(config);
 
 export default VcsApp;