@vcmap/core 5.0.0-rc.9 → 5.0.1

package/src/category/categoryCollection.ts

@@ -0,0 +1,142 @@
+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';
+
+function getLogger(): Logger {
+  return getLoggerByName('CategoryCollection');
+}
+
+/**
+ * @group Category
+ */
+class CategoryCollection extends IndexedCollection<Category> {
+  private _app: VcsApp;
+
+  /**
+   * Map of category names, where the value is a map of moduleId and items.
+   */
+  private _cache: Map<string, Map<string, object[]>> = new Map();
+
+  private _moduleRemovedListener: () => void;
+
+  constructor(app: VcsApp) {
+    super();
+
+    this._app = app;
+
+    this._moduleRemovedListener = this._app.moduleRemoved.addEventListener(
+      (module) => {
+        this._cache.forEach((moduleMap, name) => {
+          moduleMap.delete(module._id);
+          if (moduleMap.size === 0) {
+            this._cache.delete(name);
+          }
+        });
+      },
+    );
+  }
+
+  /**
+   * Do not call add directly. Use request category for adding categories.
+   */
+  add(category: Category): number | null {
+    // XXX use a symbol to enforce using request over add?
+    if (this.hasKey(category.name)) {
+      return null;
+    }
+
+    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) => {
+        // eslint-disable-next-line no-void
+        void this.parseCategoryItems(category.name, items, moduleId);
+      });
+
+      this._cache.delete(category.name);
+    }
+    return added;
+  }
+
+  /**
+   * Categories should be static. Removing them can lead to undefined behavior.
+   */
+  remove(category: Category): void {
+    // XXX add logger warning?
+    super.remove(category);
+    this._cache.delete(category.name);
+  }
+
+  /**
+   * 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.
+   */
+  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);
+    } else {
+      this._cache.set(name, new Map([[moduleId, items]]));
+    }
+  }
+
+  /**
+   * Add categories with this API.
+   */
+  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;
+    }
+
+    if (!options.type) {
+      getLogger().warning(
+        `Implicitly typing category ${options.name} as ${Category.className}`,
+      );
+      options.type = Category.className;
+    }
+
+    let category: Category<T> | Category | null;
+    if (this.hasKey(options.name)) {
+      category = this.getByKey(options.name) as unknown as Category<T>;
+      category.mergeOptions(options);
+    } else {
+      category = getObjectFromClassRegistry(
+        this._app.categoryClassRegistry,
+        options,
+      );
+      if (category) {
+        if (this.add(category) == null) {
+          return null;
+        }
+      }
+    }
+
+    if (!category) {
+      throw new Error(
+        `Category ${options.name} with type ${options.type} could not be created`,
+      );
+    }
+    return category as Category<T>;
+  }
+
+  destroy(): void {
+    super.destroy();
+    this._moduleRemovedListener();
+    this._cache.clear();
+  }
+}
+
+export default CategoryCollection;

package/src/cesium/cesium.d.ts

@@ -0,0 +1,257 @@
+/**
+ * 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,
+  updateFeatureOverride,
+} 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;
+    [updateFeatureOverride]?: () => void;
+  }
+
+  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,7 +10,9 @@ import {
   PerInstanceColorAppearance,
   FrustumOutlineGeometry,
   destroyObject,
-} from '@vcmap/cesium';
+  type Camera,
+  type PerspectiveFrustum,
+} from '@vcmap-cesium/engine';
 
 const scratchRight = new Cartesian3();
 const scratchRotation = new Matrix3();
@@ -20,34 +21,39 @@ const scratchOrientation = new Quaternion();
 const scratchColor = new Color();
 const scratchSplits = [1.0, 100000.0];
 
-/**
- * @typedef {Object} VcsCameraPrimitiveOptions
- * @property {import("@vcmap/cesium").Camera} camera
- * @property {import("@vcmap/cesium").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;
-    this.allowPicking = typeof options.allowPicking === 'undefined' ? true : options.allowPicking;
+    this.allowPicking =
+      typeof options.allowPicking === 'undefined' ? true : options.allowPicking;
     this.id = options.id || {};
   }
 
-  update(frameState) {
+  update(frameState: unknown): void {
     if (!this.show) {
       return;
     }
@@ -58,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;
@@ -74,7 +80,10 @@ class VcsCameraPrimitive {
       Matrix3.setColumn(rotation, 1, up, rotation);
       Matrix3.setColumn(rotation, 2, direction, rotation);
 
-      const orientation = Quaternion.fromRotationMatrix(rotation, scratchOrientation);
+      const orientation = Quaternion.fromRotationMatrix(
+        rotation,
+        scratchOrientation,
+      );
 
       planesPrimitives.length = 1;
       outlinePrimitives.length = 1;
@@ -89,12 +98,18 @@ class VcsCameraPrimitive {
             origin: position,
             orientation,
             frustum,
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+            // @ts-ignore
             _drawNearPlane: true,
           }),
           attributes: {
-            color: ColorGeometryInstanceAttribute.fromColor(Color.fromAlpha(this._color, 0.1, scratchColor)),
+            color: ColorGeometryInstanceAttribute.fromColor(
+              Color.fromAlpha(this._color, 0.1, scratchColor),
+            ),
           },
           id: this.id,
+          // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+          // @ts-ignore
           pickPrimitive: this,
         }),
         appearance: new PerInstanceColorAppearance({
@@ -111,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({
@@ -128,16 +147,26 @@ 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) {
-      this._outlinePrimitives[i] = this._outlinePrimitives[i] && this._outlinePrimitives[i].destroy();
-      this._planesPrimitives[i] = this._planesPrimitives[i] && this._planesPrimitives[i].destroy();
+      // 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();
     }
     return destroyObject(this);
   }

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,5 +1,4 @@
-// @ts-nocheck
-import { Material, Cartesian2 } from '@vcmap/cesium';
+import { Material, Cartesian2 } from '@vcmap-cesium/engine';
 
 /**
  * @file Wallpaper Material to implement openlayers pattern support in cesium
@@ -15,8 +14,10 @@ Material._materialCache.addMaterial('Wallpaper', {
       anchor: new Cartesian2(0, 0),
     },
     components: {
-      diffuse: 'texture2D(image, fract((gl_FragCoord.xy - anchor.xy) / vec2(imageDimensions.xy))).rgb',
-      alpha: 'texture2D(image, fract((gl_FragCoord.xy - anchor.xy) / vec2(imageDimensions.xy))).a',
+      diffuse:
+        'texture2D(image, fract((gl_FragCoord.xy - anchor.xy) / vec2(imageDimensions.xy))).rgb',
+      alpha:
+        'texture2D(image, fract((gl_FragCoord.xy - anchor.xy) / vec2(imageDimensions.xy))).a',
     },
   },
   translucent: false,