@vcmap/core 5.0.0-rc.32 → 5.0.0-rc.34

package/src/category/{categoryCollection.js → categoryCollection.ts}

@@ -1,40 +1,29 @@
-import { getLogger as getLoggerByName } from '@vcsuite/logger';
-import Category from './category.js';
+import { getLogger as getLoggerByName, type Logger } from '@vcsuite/logger';
+import Category, { CategoryOptions } from './category.js';
 import IndexedCollection from '../util/indexedCollection.js';
 import { getObjectFromClassRegistry } from '../classRegistry.js';
+import type VcsApp from '../vcsApp.js';
+import VcsObject from '../vcsObject.js';
 
-/**
- * @returns {import("@vcsuite/logger").Logger}
- */
-function getLogger() {
+function getLogger(): Logger {
   return getLoggerByName('CategoryCollection');
 }
 
-/**
- * @class
- * @extends {IndexedCollection<Category<Object|import("@vcmap/core").VcsObject>>}
- */
-class CategoryCollection extends IndexedCollection {
+class CategoryCollection extends IndexedCollection<Category> {
+  private _app: VcsApp;
+
   /**
-   * @param {import("@vcmap/core").VcsApp} app
+   * Map of category names, where the value is a map of moduleId and items.
    */
-  constructor(app) {
+  private _cache: Map<string, Map<string, object[]>> = new Map();
+
+  private _moduleRemovedListener: () => void;
+
+  constructor(app: VcsApp) {
     super();
-    /**
-     * @type {import("@vcmap/core").VcsApp}
-     * @private
-     */
+
     this._app = app;
-    /**
-     * Map of category names, where the value is a map of moduleId and items.
-     * @type {Map<string, Map<string, Array<Object>>>}
-     * @private
-     */
-    this._cache = new Map();
-    /**
-     * @type {Function}
-     * @private
-     */
+
     this._moduleRemovedListener = this._app.moduleRemoved.addEventListener(
       (module) => {
         this._cache.forEach((moduleMap, name) => {
@@ -49,10 +38,8 @@ class CategoryCollection extends IndexedCollection {
 
   /**
    * Do not call add directly. Use request category for adding categories.
-   * @param {Category<Object|import("@vcmap/core").VcsObject>} category
-   * @returns {number|null}
    */
-  add(category) {
+  add(category: Category): number | null {
     // XXX use a symbol to enforce using request over add?
     if (this.hasKey(category.name)) {
       return null;
@@ -61,8 +48,9 @@ class CategoryCollection extends IndexedCollection {
     category.setApp(this._app);
     const added = super.add(category);
     if (added != null && this._cache.has(category.name)) {
-      this._cache.get(category.name).forEach((items, moduleId) => {
-        this.parseCategoryItems(category.name, items, moduleId);
+      this._cache.get(category.name)!.forEach((items, moduleId) => {
+        // eslint-disable-next-line no-void
+        void this.parseCategoryItems(category.name, items, moduleId);
       });
 
       this._cache.delete(category.name);
@@ -72,9 +60,8 @@ class CategoryCollection extends IndexedCollection {
 
   /**
    * Categories should be static. Removing them can lead to undefined behavior.
-   * @param {Category<Object|import("@vcmap/core").VcsObject>} category
    */
-  remove(category) {
+  remove(category: Category): void {
     // XXX add logger warning?
     super.remove(category);
     this._cache.delete(category.name);
@@ -83,18 +70,18 @@ class CategoryCollection extends IndexedCollection {
   /**
    * Parses the category items. Items will only be parsed, if a category with said name exists. Otherwise,
    * they will be cached, until such a category is requested.
-   * @param {string} name
-   * @param {Array<Object>} items
-   * @param {string} moduleId
-   * @returns {Promise<void>}
    */
-  async parseCategoryItems(name, items, moduleId) {
+  async parseCategoryItems(
+    name: string,
+    items: object[],
+    moduleId: string,
+  ): Promise<void> {
     const category = this.getByKey(name);
 
     if (category) {
       await category.collection.parseItems(items, moduleId);
     } else if (this._cache.has(name)) {
-      this._cache.get(name).set(moduleId, items);
+      this._cache.get(name)!.set(moduleId, items);
     } else {
       this._cache.set(name, new Map([[moduleId, items]]));
     }
@@ -102,10 +89,10 @@ class CategoryCollection extends IndexedCollection {
 
   /**
    * Add categories with this API.
-   * @param {CategoryOptions} options
-   * @returns {Promise<Category<Object|import("@vcmap/core").VcsObject>>}
    */
-  async requestCategory(options) {
+  requestCategory<T extends VcsObject | object>(
+    options: CategoryOptions<T>,
+  ): Category<T> | null {
     if (!options.name) {
       getLogger().error('Cannot request a category without a name');
       return null;
@@ -118,12 +105,12 @@ class CategoryCollection extends IndexedCollection {
       options.type = Category.className;
     }
 
-    let category;
+    let category: Category<T> | Category | null;
     if (this.hasKey(options.name)) {
-      category = this.getByKey(options.name);
+      category = this.getByKey(options.name) as unknown as Category<T>;
       category.mergeOptions(options);
     } else {
-      category = await getObjectFromClassRegistry(
+      category = getObjectFromClassRegistry(
         this._app.categoryClassRegistry,
         options,
       );
@@ -139,14 +126,13 @@ class CategoryCollection extends IndexedCollection {
         `Category ${options.name} with type ${options.type} could not be created`,
       );
     }
-    return category;
+    return category as Category<T>;
   }
 
-  destroy() {
+  destroy(): void {
     super.destroy();
     this._moduleRemovedListener();
     this._cache.clear();
-    this._app = null;
   }
 }
 

package/src/cesium/cesium.d.ts

@@ -0,0 +1,253 @@
+/**
+ * Type overrides for types extended by the @vcmap/core API
+ */
+// eslint-disable-next-line max-classes-per-file
+import {
+  Cartesian2,
+  Cartesian3,
+  Cartesian4,
+  Color,
+} from '@vcmap-cesium/engine';
+import { StyleLike } from 'ol/style/Style.js';
+import VectorStyleItem from '../style/vectorStyleItem.js';
+import { scaleSymbol } from '../layer/cesium/vectorContext.js';
+import { vcsLayerName } from '../layer/layerSymbols.js';
+import {
+  globalHidden,
+  hidden,
+  highlighted,
+  originalStyle,
+} from '../layer/featureVisibility.js';
+import { handlerSymbol } from '../util/editor/editorSymbols.js';
+import { AxisAndPlanes } from '../util/editor/transformation/transformationTypes.js';
+import { cesiumTilesetLastUpdated } from '../layer/cesium/cesiumTilesetCesiumImpl.js';
+import { isTiledFeature } from '../layer/featureStoreLayer.js';
+
+declare module '@vcmap-cesium/engine' {
+  interface Scene {
+    render(): void;
+    frameState: FrameState;
+    context: Context;
+  }
+
+  interface TileBoundingVolume {
+    boundingVolume?: object;
+    boundingSphere?: BoundingSphere;
+    rectangle?: Rectangle;
+    distanceToCamera(frameState: object): number;
+    intersectPlane(plane: Plane): Intersect;
+  }
+
+  interface Entity {
+    allowPicking?: boolean;
+    attributes?: Record<string, unknown>;
+    olFeature?: import('ol').Feature<import('ol/geom.js').Geometry>;
+    getId(): number | string;
+    getProperty(key: string): any;
+    getPropertyInherited(key: string): any;
+    [vcsLayerName]?: string;
+    [globalHidden]?: boolean;
+    [hidden]?: boolean;
+    [highlighted]?: VectorStyleItem;
+    [originalStyle]?: StyleLike | Color;
+  }
+
+  interface Primitive {
+    olFeature?: import('ol').Feature<import('ol/geom.js').Geometry>;
+    [handlerSymbol]?: AxisAndPlanes;
+  }
+
+  interface Model {
+    olFeature?: import('ol').Feature<import('ol/geom.js').Geometry>;
+    [scaleSymbol]?: number;
+  }
+
+  interface GroundPrimitive {
+    olFeature?: import('ol').Feature<import('ol/geom.js').Geometry>;
+  }
+
+  interface GroundPolylinePrimitive {
+    olFeature?: import('ol').Feature<import('ol/geom.js').Geometry>;
+  }
+
+  interface ClassificationPrimitive {
+    olFeature?: import('ol').Feature<import('ol/geom.js').Geometry>;
+  }
+
+  interface Label {
+    olFeature?: import('ol').Feature<import('ol/geom.js').Geometry>;
+  }
+
+  interface Billboard {
+    olFeature?: import('ol').Feature<import('ol/geom.js').Geometry>;
+  }
+
+  interface ImageryProvider {
+    _reload?(): void;
+  }
+
+  interface PrimitiveCollection {
+    VCMLayerIndex?: number;
+    [vcsLayerName]?: string;
+  }
+
+  interface CustomDataSource {
+    [vcsLayerName]?: string;
+  }
+
+  interface CzmlDataSource {
+    [vcsLayerName]?: string;
+  }
+
+  interface DataSource {
+    [vcsLayerName]?: string;
+  }
+
+  interface ImageryLayer {
+    VCMLayerIndex?: number;
+    [vcsLayerName]?: string;
+  }
+
+  interface TerrainProvider {
+    [vcsLayerName]?: string;
+  }
+
+  interface Cesium3DTile {
+    boundingVolume: TileBoundingVolume;
+    contentReady: boolean;
+    [cesiumTilesetLastUpdated]?: number;
+  }
+
+  interface Cesium3DTileContent {
+    readonly batchTable: Cesium3DTileBatchTable;
+    isDestroyed(): boolean;
+    [cesiumTilesetLastUpdated]?: number;
+  }
+
+  interface Cesium3DTileset {
+    clippingPlanesOriginMatrix: Matrix4;
+    [vcsLayerName]: string;
+    [isTiledFeature]?: boolean;
+  }
+
+  interface CesiumTerrainProvider {
+    [vcsLayerName]?: string;
+  }
+
+  interface DataSourceDisplay {
+    getBoundingSphere(
+      entity: Entity,
+      allowPartial: boolean,
+      result: BoundingSphere,
+    ): BoundingSphereState;
+  }
+
+  interface Cesium3DTileFeature {
+    content: Cesium3DTileContent;
+    _batchId: number;
+    getId(): number | string;
+    [vcsLayerName]?: string;
+    [globalHidden]?: boolean;
+    [hidden]?: boolean;
+    [highlighted]?: VectorStyleItem;
+    [originalStyle]?: StyleLike | Color;
+    [isTiledFeature]?: boolean;
+  }
+
+  interface Cesium3DTilePointFeature {
+    content: Cesium3DTileContent;
+    _batchId: number;
+    getId(): number | string;
+    [vcsLayerName]?: string;
+    [globalHidden]?: boolean;
+    [hidden]?: boolean;
+    [highlighted]?: VectorStyleItem;
+    [originalStyle]?: StyleLike | Color;
+  }
+
+  interface Cesium3DTileStyle {
+    strokeColor: StyleExpression;
+    strokeWidth: StyleExpression;
+    scale: StyleExpression;
+  }
+
+  interface StyleExpression {
+    evaluate<
+      T extends
+        | boolean
+        | number
+        | string
+        | RegExp
+        | Cartesian2
+        | Cartesian3
+        | Cartesian4
+        | Color = string,
+    >(
+      feature:
+        | Cesium3DTileFeature
+        | import('ol/Feature.js').default<
+            import('ol/geom/Geometry.js').default
+          >,
+      result?: any,
+    ): T | undefined;
+    evaluateColor(
+      feature:
+        | Cesium3DTileFeature
+        | import('ol/Feature.js').default<
+            import('ol/geom/Geometry.js').default
+          >,
+      result?: Color,
+    ): Color;
+  }
+
+  interface Expression {
+    evaluate(
+      feature:
+        | Cesium3DTileFeature
+        | import('ol/Feature.js').default<
+            import('ol/geom/Geometry.js').default
+          >,
+      result?: any,
+    ): any;
+    evaluateColor(
+      feature:
+        | Cesium3DTileFeature
+        | import('ol/Feature.js').default<
+            import('ol/geom/Geometry.js').default
+          >,
+      result?: Color,
+    ): Color;
+  }
+
+  interface ShadowMap {
+    viewshed?: {
+      shadowColor?: Color;
+      visibleColor?: Color;
+      distance?: number;
+    };
+  }
+
+  interface ScreenSpaceEventHandler {
+    _positions: Cartesian2[];
+  }
+
+  export class Cesium3DTileBatchTable {
+    isDestroyed(): boolean;
+  }
+
+  class Context {
+    fragmentDepth: boolean;
+  }
+
+  class FrameState {
+    context: Context;
+
+    creditDisplay: CreditDisplay;
+
+    frameNumber: number;
+  }
+
+  export namespace PolygonPipeline {
+    function triangulate(positions: Cartesian2[], holes?: number[]): number[];
+  }
+}

package/src/cesium/cesium3DTileFeature.ts

@@ -0,0 +1,10 @@
+import { Cesium3DTileFeature } from '@vcmap-cesium/engine';
+
+Cesium3DTileFeature.prototype.getId = function getId(
+  this: Cesium3DTileFeature,
+): string | number {
+  return (
+    (this.getProperty('id') as string | number) ||
+    `${this.content.url}${this._batchId}`
+  ); // XXX there is a new property `featureId` on the Cesium3DTileset. this may cause issues when picking b3dm.
+};

package/src/cesium/cesium3DTilePointFeature.ts

@@ -0,0 +1,10 @@
+import { Cesium3DTilePointFeature } from '@vcmap-cesium/engine';
+
+Cesium3DTilePointFeature.prototype.getId = function getId(
+  this: Cesium3DTilePointFeature,
+): string | number {
+  return (
+    (this.getProperty('id') as string | number) ||
+    `${this.content.url}${this._batchId}`
+  );
+};

package/src/cesium/{cesiumVcsCameraPrimitive.js → cesiumVcsCameraPrimitive.ts}

@@ -1,4 +1,3 @@
-// @ts-nocheck
 import {
   Cartesian3,
   Matrix3,
@@ -11,6 +10,8 @@ import {
   PerInstanceColorAppearance,
   FrustumOutlineGeometry,
   destroyObject,
+  type Camera,
+  type PerspectiveFrustum,
 } from '@vcmap-cesium/engine';
 
 const scratchRight = new Cartesian3();
@@ -20,26 +21,30 @@ const scratchOrientation = new Quaternion();
 const scratchColor = new Color();
 const scratchSplits = [1.0, 100000.0];
 
-/**
- * @typedef {Object} VcsCameraPrimitiveOptions
- * @property {import("@vcmap-cesium/engine").Camera} camera
- * @property {import("@vcmap-cesium/engine").Color|undefined} [color=Color.YELLOW]
- * @property {boolean|undefined} [show=true]
- * @property {boolean|undefined} [allowPicking=true]
- * @property {Object|undefined} id
- */
-
-/**
- * @class
- */
+export type VcsCameraPrimitiveOptions = {
+  camera: Camera;
+  color?: Color;
+  show?: boolean;
+  allowPicking?: boolean;
+  id?: object;
+};
+
 class VcsCameraPrimitive {
-  /**
-   * @param {VcsCameraPrimitiveOptions} options
-   */
-  constructor(options) {
-    this._outlinePrimitives = [];
-    this._planesPrimitives = [];
-    /** @type {boolean} */
+  private _outlinePrimitives: Primitive[] = [];
+
+  private _planesPrimitives: Primitive[] = [];
+
+  show = true;
+
+  private _camera: Camera;
+
+  private _color: Color;
+
+  private allowPicking = true;
+
+  private id: object = {};
+
+  constructor(options: VcsCameraPrimitiveOptions) {
     this.show = typeof options.show === 'undefined' ? true : options.show;
     this._camera = options.camera;
     this._color = options.color || Color.YELLOW;
@@ -48,7 +53,7 @@ class VcsCameraPrimitive {
     this.id = options.id || {};
   }
 
-  update(frameState) {
+  update(frameState: unknown): void {
     if (!this.show) {
       return;
     }
@@ -59,7 +64,7 @@ class VcsCameraPrimitive {
     if (planesPrimitives.length === 0) {
       const camera = this._camera;
       const cameraFrustum = camera.frustum;
-      const frustum = cameraFrustum.clone();
+      const frustum = cameraFrustum.clone() as PerspectiveFrustum;
       const frustumSplits = scratchSplits; // Use near and far planes if no splits created
       frustumSplits[0] = this._camera.frustum.near;
       frustumSplits[1] = this._camera.frustum.far;
@@ -93,6 +98,8 @@ class VcsCameraPrimitive {
             origin: position,
             orientation,
             frustum,
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+            // @ts-ignore
             _drawNearPlane: true,
           }),
           attributes: {
@@ -101,6 +108,8 @@ class VcsCameraPrimitive {
             ),
           },
           id: this.id,
+          // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+          // @ts-ignore
           pickPrimitive: this,
         }),
         appearance: new PerInstanceColorAppearance({
@@ -117,12 +126,16 @@ class VcsCameraPrimitive {
             origin: position,
             orientation,
             frustum,
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+            // @ts-ignore
             _drawNearPlane: true,
           }),
           attributes: {
             color: ColorGeometryInstanceAttribute.fromColor(this._color),
           },
           id: this.id,
+          // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+          // @ts-ignore
           pickPrimitive: this,
         }),
         appearance: new PerInstanceColorAppearance({
@@ -134,16 +147,24 @@ class VcsCameraPrimitive {
     }
     const { length } = planesPrimitives;
     for (i = 0; i < length; ++i) {
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-ignore
       outlinePrimitives[i].update(frameState);
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-ignore
       planesPrimitives[i].update(frameState);
     }
   }
 
-  destroy() {
+  destroy(): void {
     const { length } = this._planesPrimitives;
     for (let i = 0; i < length; ++i) {
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-ignore
       this._outlinePrimitives[i] =
         this._outlinePrimitives[i] && this._outlinePrimitives[i].destroy();
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-ignore
       this._planesPrimitives[i] =
         this._planesPrimitives[i] && this._planesPrimitives[i].destroy();
     }

package/src/cesium/entity.ts

@@ -0,0 +1,26 @@
+import { Entity } from '@vcmap-cesium/engine';
+
+Entity.prototype.getId = function getId(this: Entity): string | number {
+  return this.id;
+};
+
+/**
+ * To be used for cesium 3D style functions
+ */
+Entity.prototype.getProperty = function getProperty(
+  this: Entity,
+  property: string,
+): any {
+  return this[property as keyof Entity];
+};
+
+/**
+ * To be used for cesium 3D style functions
+ */
+Entity.prototype.getPropertyInherited = function getPropertyInherited(
+  this: Entity,
+  property: string,
+): any {
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+  return this.getProperty(property);
+};

package/src/cesium/wallpaperMaterial.js

@@ -1,4 +1,3 @@
-// @ts-nocheck
 import { Material, Cartesian2 } from '@vcmap-cesium/engine';
 
 /**