@vcmap/core 5.0.2 → 5.1.0-rc.1

package/src/layer/featureStoreLayerChanges.ts

@@ -1,19 +1,23 @@
 import { unByKey } from 'ol/Observable.js';
 import Feature from 'ol/Feature.js';
 import { EventsKey } from 'ol/events.js';
-import { GeoJSONFeature } from 'ol/format/GeoJSON.js';
 import type { VectorSourceEvent } from 'ol/source/Vector.js';
-
+import type {
+  Feature as GeojsonFeature,
+  LineString,
+  MultiLineString,
+  MultiPoint,
+  MultiPolygon,
+  Point,
+  Polygon,
+} from 'geojson';
 import { check } from '@vcsuite/check';
-import {
-  FeatureStoreLayerState,
-  featureStoreStateSymbol,
-} from './featureStoreLayerState.js';
+import { featureStoreStateSymbol } from './featureStoreLayerState.js';
 import { parseGeoJSON, writeGeoJSONFeature } from './geojsonHelpers.js';
 import VcsObject from '../vcsObject.js';
-import { requestJson } from '../util/fetch.js';
 
 import type FeatureStoreLayer from './featureStoreLayer.js';
+import VcsEvent from '../vcsEvent.js';
 
 export type FeatureStoreTrackResults = {
   add: Feature[];
@@ -27,13 +31,25 @@ export type FeatureStoreChangesListeners = {
   removefeature: EventsKey | EventsKey[] | null;
 };
 
-export type FeatureStoreChangesValues = {
-  changed: boolean;
+export type FeatureStoreGeojsonGeometry =
+  | Point
+  | MultiPoint
+  | LineString
+  | MultiLineString
+  | Polygon
+  | MultiPolygon;
+
+export type FeatureStoreGeojsonFeature<
+  G extends FeatureStoreGeojsonGeometry = FeatureStoreGeojsonGeometry,
+  P extends Record<string, unknown> = Record<string, unknown>,
+> = Omit<GeojsonFeature<G, P>, 'id'> & {
+  _id?: string;
+  id?: string;
 };
 
 type CommitAction = {
-  action: string;
-  feature: GeoJSONFeature | { _id: string | number | undefined };
+  action: 'add' | 'edit' | 'remove';
+  feature: FeatureStoreGeojsonFeature | { _id: string };
   original: Feature;
   success(opt?: string): void;
 };
@@ -45,28 +61,32 @@ export function createCommitActions(
 ): CommitAction[] {
   const actions: CommitAction[] = [];
   added.forEach((f) => {
-    const feature = writeGeoJSONFeature(f, { writeStyle: true });
+    const feature = writeGeoJSONFeature(f, {
+      writeStyle: true,
+    }) as FeatureStoreGeojsonFeature;
     actions.push({
       action: 'add',
       feature,
       original: f,
       success(data) {
         f.setId(data);
-        f[featureStoreStateSymbol] = FeatureStoreLayerState.DYNAMIC;
+        f[featureStoreStateSymbol] = 'dynamic';
       },
     });
   });
 
   edited.forEach((f) => {
-    const feature = writeGeoJSONFeature(f, { writeStyle: true });
-    feature._id = f.getId();
+    const feature = writeGeoJSONFeature(f, {
+      writeStyle: true,
+    }) as FeatureStoreGeojsonFeature;
+    feature._id = f.getId() as string;
     actions.push({
       action: 'edit',
       original: f,
       feature,
       success() {
-        if (f[featureStoreStateSymbol] === FeatureStoreLayerState.STATIC) {
-          f[featureStoreStateSymbol] = FeatureStoreLayerState.EDITED;
+        if (f[featureStoreStateSymbol] === 'static') {
+          f[featureStoreStateSymbol] = 'edited';
         }
       },
     });
@@ -76,7 +96,7 @@ export function createCommitActions(
     actions.push({
       original: f,
       action: 'remove',
-      feature: { _id: f.getId() },
+      feature: { _id: f.getId() as string },
       success() {},
     });
   });
@@ -108,9 +128,7 @@ class FeatureStoreLayerChanges extends VcsObject {
 
   private _convertedFeatures: Set<Feature> = new Set();
 
-  values: FeatureStoreChangesValues = {
-    changed: false,
-  };
+  changed = new VcsEvent<void>();
 
   constructor(layer: FeatureStoreLayer) {
     super({});
@@ -166,12 +184,24 @@ class FeatureStoreLayerChanges extends VcsObject {
     };
   }
 
+  hasChanges(): boolean {
+    return (
+      this._addedFeatures.size !== 0 ||
+      this._editedFeatures.size !== 0 ||
+      this._removedFeatures.size !== 0
+    );
+  }
+
   /**
    * commits the changes to the provided url. url should contain accessTokens and point to a featureStore layers bulk operation endpoint
    */
   async commitChanges(
-    url: string,
-    headers: Record<string, string> = {},
+    postCallback: (
+      body: Pick<CommitAction, 'action' | 'feature'>[],
+    ) => Promise<{
+      failedActions: { index: number; error: string }[];
+      insertedIds: { _id: string }[];
+    }>,
   ): Promise<void> {
     const actions: (CommitAction | null)[] = createCommitActions(
       this._addedFeatures,
@@ -179,19 +209,9 @@ class FeatureStoreLayerChanges extends VcsObject {
       this._removedFeatures,
     );
     if (actions.length > 0) {
-      const data = await requestJson<{
-        failedActions: { index: number; error: string }[];
-        insertedIds: { _id: string }[];
-      }>(url.toString(), {
-        method: 'POST',
-        headers: {
-          ...headers,
-          'Content-Type': 'application/json',
-        },
-        body: JSON.stringify(
-          actions.map((a) => ({ action: a!.action, feature: a!.feature })),
-        ),
-      });
+      const data = await postCallback(
+        actions.map((a) => ({ action: a!.action, feature: a!.feature })),
+      );
 
       const failures = data.failedActions.map(({ index, error }) => {
         const action = actions[index] as CommitAction;
@@ -259,7 +279,7 @@ class FeatureStoreLayerChanges extends VcsObject {
       return Promise.resolve();
     }
 
-    if (feature[featureStoreStateSymbol] === FeatureStoreLayerState.STATIC) {
+    if (feature[featureStoreStateSymbol] === 'static') {
       this.layer.resetStaticFeature(featureId);
       return Promise.resolve();
     }
@@ -284,7 +304,6 @@ class FeatureStoreLayerChanges extends VcsObject {
     this._editedFeatures.clear();
     this._removedFeatures.clear();
     this._convertedFeatures.clear();
-    this.values.changed = false;
   }
 
   /**
@@ -316,12 +335,10 @@ class FeatureStoreLayerChanges extends VcsObject {
     if (feature) {
       if (!feature[featureStoreStateSymbol]) {
         this._addedFeatures.add(feature);
-        this.values.changed = true;
-      } else if (
-        feature[featureStoreStateSymbol] === FeatureStoreLayerState.STATIC
-      ) {
+        this.changed.raiseEvent();
+      } else if (feature[featureStoreStateSymbol] === 'static') {
         this._convertedFeatures.add(feature);
-        this.values.changed = true;
+        this.changed.raiseEvent();
       }
     }
   }
@@ -334,7 +351,7 @@ class FeatureStoreLayerChanges extends VcsObject {
       if (feature[featureStoreStateSymbol]) {
         this._convertedFeatures.delete(feature);
         this._editedFeatures.add(feature);
-        this.values.changed = true;
+        this.changed.raiseEvent();
       }
     }
   }
@@ -348,7 +365,7 @@ class FeatureStoreLayerChanges extends VcsObject {
         this._removedFeatures.add(feature);
         this._editedFeatures.delete(feature);
         this._convertedFeatures.delete(feature);
-        this.values.changed = true;
+        this.changed.raiseEvent();
       } else {
         this._addedFeatures.delete(feature);
       }
@@ -385,6 +402,7 @@ class FeatureStoreLayerChanges extends VcsObject {
   destroy(): void {
     this.unTrack();
     this._layer = undefined;
+    this.changed.destroy();
     super.destroy();
   }
 }

package/src/layer/featureStoreLayerState.ts

@@ -3,8 +3,9 @@ export const featureStoreStateSymbol = Symbol('vcsFeatureType');
 /**
  * Enumeration of feature store item states
  */
-export enum FeatureStoreLayerState {
-  DYNAMIC = 'dynamic',
-  STATIC = 'static',
-  EDITED = 'edited',
-}
+export type FeatureStoreLayerState =
+  | 'dynamic'
+  | 'static'
+  | 'edited'
+  | 'deleted'
+  | 'removed';

package/src/layer/geojsonLayer.ts

@@ -1,11 +1,10 @@
 import type { GeoJSONFeature } from 'ol/format/GeoJSON.js';
 import { FeatureCollection } from 'geojson';
-
 import VectorLayer, { VectorOptions } from './vectorLayer.js';
 import { parseGeoJSON, writeGeoJSONFeature } from './geojsonHelpers.js';
 import Projection, { wgs84Projection } from '../util/projection.js';
 import { layerClassRegistry } from '../classRegistry.js';
-import { requestJson } from '../util/fetch.js';
+import { getInitForUrl, requestJson } from '../util/fetch.js';
 
 export type GeoJSONOptions = VectorOptions & {
   features?: GeoJSONFeature[];
@@ -86,7 +85,8 @@ class GeoJSONLayer extends VectorLayer {
     }
 
     if (this.url) {
-      this._dataFetchedPromise = requestJson(this.url)
+      const init = getInitForUrl(this.url, this.headers);
+      this._dataFetchedPromise = requestJson(this.url, init)
         .then((data) => this._parseGeojsonData(data as FeatureCollection))
         .catch((err) => {
           this.getLogger().warning(

package/src/layer/layer.ts

@@ -1,4 +1,5 @@
-import { check, checkMaybe } from '@vcsuite/check';
+import deepEqual from 'fast-deep-equal';
+import { check, maybe, oneOf, optional, recordOf } from '@vcsuite/check';
 import { parseBoolean, parseInteger } from '@vcsuite/parsers';
 import VcsObject, { VcsObjectOptions } from '../vcsObject.js';
 import Extent, { type ExtentOptions } from '../util/extent.js';
@@ -50,11 +51,17 @@ export type LayerOptions = VcsObjectOptions & {
    * to other sources of data.
    */
   datasourceId?: string;
+
+  /**
+   * Optional Request Headers which will be sent with each request.
+   */
+  headers?: Record<string, string>;
 };
 
 export type LayerImplementationOptions = {
   name: string;
   url: string;
+  headers?: Record<string, string>;
 };
 
 /**
@@ -82,6 +89,7 @@ class Layer<
       hiddenObjectIds: [],
       copyright: undefined,
       datasourceId: undefined,
+      headers: undefined,
     };
   }
 
@@ -145,6 +153,8 @@ class Layer<
 
   private _locale: string;
 
+  protected _headers?: Record<string, string>;
+
   /**
    * Optional Id to synchronize with the vcPublisher Datasources. This can also be used to track a connection
    * to other sources of data.
@@ -208,6 +218,8 @@ class Layer<
     this._locale = 'en';
 
     this.datasourceId = options.datasourceId || defaultOptions.datasourceId;
+
+    this._headers = structuredClone(options.headers);
   }
 
   /**
@@ -254,7 +266,7 @@ class Layer<
   }
 
   set url(url: string | Record<string, string>) {
-    check(url, [String, Object]);
+    check(url, oneOf(String, recordOf(String)));
 
     if (this._url !== url) {
       const currentValue = this._url;
@@ -285,7 +297,7 @@ class Layer<
   }
 
   setGlobalHider(globalHider?: GlobalHider): void {
-    checkMaybe(globalHider, GlobalHider);
+    check(globalHider, maybe(GlobalHider));
 
     if (globalHider && this.active) {
       globalHider.hideObjects(this.hiddenObjectIds);
@@ -308,7 +320,7 @@ class Layer<
   }
 
   set exclusiveGroups(groups: (string | symbol)[]) {
-    check(groups, [[String, Symbol]]);
+    check(groups, [oneOf(String, Symbol)]);
 
     if (
       groups.length !== this._exclusiveGroups.length ||
@@ -332,6 +344,26 @@ class Layer<
     }
   }
 
+  /**
+   * directly manipulating the headers Object will not trigger a reload. Reload the data via layer.reload() manually.
+   */
+  get headers(): Record<string, string> | undefined {
+    return this._headers;
+  }
+
+  /**
+   *
+   * @param headers
+   */
+  set headers(headers: Record<string, string> | undefined) {
+    check(headers, optional(recordOf(String)));
+    if (!deepEqual(this._headers, headers)) {
+      this._headers = structuredClone(headers);
+      // eslint-disable-next-line no-void
+      void this.reload();
+    }
+  }
+
   /**
    * returns the currently set locale. Can be used to provide locale specific URLs.
    */
@@ -397,6 +429,7 @@ class Layer<
     return {
       name: this.name,
       url: this.url,
+      headers: this.headers,
     };
   }
 
@@ -652,6 +685,10 @@ class Layer<
       config.datasourceId = this.datasourceId;
     }
 
+    if (!deepEqual(this._headers, defaultOptions.headers)) {
+      config.headers = structuredClone(this._headers);
+    }
+
     return config;
   }
 

package/src/layer/layerImplementation.ts

@@ -19,10 +19,13 @@ class LayerImplementation<M extends VcsMap> extends VcsObject {
 
   private _initialized = false;
 
+  headers?: Record<string, string>;
+
   constructor(map: M, options: LayerImplementationOptions) {
     super(options);
     this._map = map;
     this.url = options.url;
+    this.headers = options.headers;
   }
 
   get map(): M {

package/src/layer/oblique/vectorObliqueImpl.ts

@@ -182,7 +182,7 @@ class VectorObliqueImpl
     }
   }
 
-  private addFeature(originalFeature: Feature): Promise<void> {
+  private async addFeature(originalFeature: Feature): Promise<void> {
     if (!this.active) {
       this.fetchedFeaturesForImageName = null;
     }
@@ -196,7 +196,7 @@ class VectorObliqueImpl
         return Promise.resolve();
       }
 
-      if (this.obliqueSource.getFeatureById(id)) {
+      if (this.obliqueSource.getFeatureById(id) || this._updatingOblique[id]) {
         return Promise.resolve();
       }
       const obliqueFeature = new Feature({});
@@ -207,11 +207,8 @@ class VectorObliqueImpl
 
       this._setFeatureListeners(originalFeature, obliqueFeature);
 
-      return this._convertToOblique(originalFeature, obliqueFeature).then(
-        () => {
-          this.obliqueSource.addFeature(obliqueFeature);
-        },
-      );
+      await this._convertToOblique(originalFeature, obliqueFeature);
+      this.obliqueSource.addFeature(obliqueFeature);
     }
     return Promise.resolve();
   }
@@ -308,8 +305,9 @@ class VectorObliqueImpl
     const vectorGeometry = originalFeature.getGeometry() as Geometry;
     const imageGeometry = obliqueFeature.getGeometry() as Geometry;
     this._updatingOblique[id] = true;
+    let promise: Promise<unknown>;
     if (!vectorGeometry[alreadyTransformedToImage]) {
-      await mercatorGeometryToImageGeometry(
+      promise = mercatorGeometryToImageGeometry(
         vectorGeometry,
         imageGeometry,
         this.map.currentImage as ObliqueImage,
@@ -318,7 +316,10 @@ class VectorObliqueImpl
       obliqueFeature
         .getGeometry()!
         .setCoordinates(vectorGeometry.getCoordinates());
+      // we MUST wait for a promise, otherwise this is sync and you can add a feature twice
+      promise = Promise.resolve();
     }
+    await promise;
     this._updatingOblique[id] = null;
   }
 

package/src/layer/openlayers/loadFunctionHelpers.ts

@@ -0,0 +1,24 @@
+import type { LoadFunction } from 'ol/Tile.js';
+import type { ImageTile } from 'ol';
+import TileState from 'ol/TileState.js';
+import { getInitForUrl, requestObjectUrl } from '../../util/fetch.js';
+
+// eslint-disable-next-line import/prefer-default-export
+export function getTileLoadFunction(
+  headers: Record<string, string>,
+): LoadFunction {
+  return function tileLoadFunction(imageTile, src): void {
+    const image = (imageTile as ImageTile).getImage() as HTMLImageElement;
+    const init = getInitForUrl(src, headers);
+    requestObjectUrl(src, init)
+      .then((blobUrl) => {
+        image.src = blobUrl;
+        image.onload = (): void => {
+          URL.revokeObjectURL(blobUrl);
+        };
+      })
+      .catch(() => {
+        imageTile.setState(TileState.ERROR);
+      });
+  };
+}

package/src/layer/openlayers/singleImageOpenlayersImpl.ts

@@ -1,4 +1,5 @@
 import ImageLayer from 'ol/layer/Image.js';
+import { TrustedServers } from '@vcmap-cesium/engine';
 import ImageStatic, {
   type Options as ImageStaticOptions,
 } from 'ol/source/ImageStatic.js';
@@ -7,6 +8,7 @@ import { wgs84Projection } from '../../util/projection.js';
 import { isSameOrigin } from '../../util/urlHelpers.js';
 import type { SingleImageImplementationOptions } from '../singleImageLayer.js';
 import type OpenlayersMap from '../../map/openlayersMap.js';
+import { getInitForUrl, requestObjectUrl } from '../../util/fetch.js';
 
 /**
  * represents a specific OpenLayers SingleImageLayer Layer class.
@@ -33,10 +35,32 @@ class SingleImageOpenlayersImpl extends RasterLayerOpenlayersImpl {
       projection: 'EPSG:4326',
       imageExtent: this.extent.getCoordinatesInProjection(wgs84Projection),
     };
-    if (!isSameOrigin(this.url as string)) {
+    if (TrustedServers.contains(options.url)) {
+      options.crossOrigin = 'use-credentials';
+    } else if (!isSameOrigin(this.url as string)) {
       options.crossOrigin = 'anonymous';
     }
 
+    if (this.headers) {
+      options.imageLoadFunction = (imageWrapper, src): void => {
+        const init = getInitForUrl(src, this.headers);
+        requestObjectUrl(src, init)
+          .then((blobUrl) => {
+            const image = imageWrapper.getImage() as HTMLImageElement;
+            image.src = blobUrl;
+            image.onload = (): void => {
+              URL.revokeObjectURL(blobUrl);
+            };
+          })
+          .catch(() => {
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+            // @ts-ignore
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-call,no-underscore-dangle
+            imageWrapper.handleImageError_();
+          });
+      };
+    }
+
     return new ImageLayer({
       source: new ImageStatic(options),
       opacity: this.opacity,

package/src/layer/openlayers/tmsOpenlayersImpl.ts

@@ -1,3 +1,4 @@
+import { TrustedServers } from '@vcmap-cesium/engine';
 import XYZ, { type Options as XYZOptions } from 'ol/source/XYZ.js';
 import Tile from 'ol/layer/Tile.js';
 import { type Options as TileOptions } from 'ol/layer/BaseTile.js';
@@ -8,6 +9,7 @@ import { TilingScheme } from '../rasterLayer.js';
 import { isSameOrigin } from '../../util/urlHelpers.js';
 import type { TMSImplementationOptions } from '../tmsLayer.js';
 import type OpenlayersMap from '../../map/openlayersMap.js';
+import { getTileLoadFunction } from './loadFunctionHelpers.js';
 
 /**
  * TmsLayer implementation for {@link OpenlayersMap}.
@@ -43,12 +45,17 @@ class TmsOpenlayersImpl extends RasterLayerOpenlayersImpl {
       maxZoom: this.maxLevel,
       wrapX: false,
     };
-    if (!isSameOrigin(this.url as string)) {
+    if (TrustedServers.contains(this.url as string)) {
+      sourceOptions.crossOrigin = 'use-credentials';
+    } else if (!isSameOrigin(this.url as string)) {
       sourceOptions.crossOrigin = 'anonymous';
     }
     if (this.tilingSchema === TilingScheme.GEOGRAPHIC) {
       sourceOptions.projection = 'EPSG:4326';
     }
+    if (this.headers) {
+      sourceOptions.tileLoadFunction = getTileLoadFunction(this.headers);
+    }
 
     const tileOptions: TileOptions<XYZ> = {
       source: new XYZ(sourceOptions),

package/src/layer/openlayers/vectorTileOpenlayersImpl.ts

@@ -67,6 +67,7 @@ class VectorTileOpenlayersImpl
           tile.tileCoord[1],
           tile.tileCoord[2],
           tile.tileCoord[0],
+          this.headers,
         );
         if (features.length > 0) {
           tile.setFeatures(features);

package/src/layer/openlayers/wmsOpenlayersImpl.ts

@@ -1,10 +1,13 @@
 import Tile from 'ol/layer/Tile.js';
 import type { Size } from 'ol/size.js';
 import type TileWMS from 'ol/source/TileWMS.js';
+import ImageWMS from 'ol/source/ImageWMS.js';
+import ImageLayer from 'ol/layer/Image.js';
 import RasterLayerOpenlayersImpl from './rasterLayerOpenlayersImpl.js';
-import { getWMSSource } from '../wmsHelpers.js';
+import { getImageWMSSource, getWMSSource } from '../wmsHelpers.js';
 import type { WMSImplementationOptions } from '../wmsLayer.js';
 import type OpenlayersMap from '../../map/openlayersMap.js';
+import { mercatorProjection } from '../../util/projection.js';
 
 /**
  * represents a specific Cesium WmsOpenlayersImpl Layer class.
@@ -20,14 +23,31 @@ class WmsOpenlayersImpl extends RasterLayerOpenlayersImpl {
 
   tileSize: Size;
 
+  singleImage2d: boolean;
+
   constructor(map: OpenlayersMap, options: WMSImplementationOptions) {
     super(map, options);
     this.parameters = options.parameters;
     this.version = options.version;
     this.tileSize = options.tileSize;
+    this.singleImage2d = options.singleImage2d;
   }
 
-  getOLLayer(): Tile<TileWMS> {
+  getOLLayer(): Tile<TileWMS> | ImageLayer<ImageWMS> {
+    if (this.singleImage2d) {
+      return new ImageLayer({
+        extent: this.extent.getCoordinatesInProjection(mercatorProjection),
+        visible: false,
+        source: getImageWMSSource({
+          url: this.url as string,
+          parameters: this.parameters,
+          tilingSchema: this.tilingSchema,
+          version: this.version,
+          headers: this.headers,
+        }),
+        opacity: this.opacity,
+      });
+    }
     return new Tile({
       visible: false,
       source: getWMSSource({
@@ -39,6 +59,7 @@ class WmsOpenlayersImpl extends RasterLayerOpenlayersImpl {
         minLevel: this.minLevel,
         maxLevel: this.maxLevel,
         tilingSchema: this.tilingSchema,
+        headers: this.headers,
       }),
       opacity: this.opacity,
     });

package/src/layer/openlayers/wmtsOpenlayersImpl.ts

@@ -1,3 +1,4 @@
+import { TrustedServers } from '@vcmap-cesium/engine';
 import { getTopLeft, getWidth } from 'ol/extent.js';
 import WMTSTileGrid, {
   type Options as WMTSTileGridOptions,
@@ -11,6 +12,7 @@ import { TilingScheme } from '../rasterLayer.js';
 import { isSameOrigin } from '../../util/urlHelpers.js';
 import type { WMTSImplementationOptions } from '../wmtsLayer.js';
 import type OpenlayersMap from '../../map/openlayersMap.js';
+import { getTileLoadFunction } from './loadFunctionHelpers.js';
 
 /**
  * WmtsLayer implementation for {@link OpenlayersMap}.
@@ -106,13 +108,18 @@ class WmtsOpenlayersImpl extends RasterLayerOpenlayersImpl {
       url: this.url,
     };
 
-    if (!isSameOrigin(this.url as string)) {
+    if (TrustedServers.contains(this.url as string)) {
+      wmtsOptions.crossOrigin = 'use-credentials';
+    } else if (!isSameOrigin(this.url as string)) {
       wmtsOptions.crossOrigin = 'anonymous';
     }
 
     if (this.tilingSchema === TilingScheme.GEOGRAPHIC) {
       wmtsOptions.projection = 'EPSG:4326';
     }
+    if (this.headers) {
+      wmtsOptions.tileLoadFunction = getTileLoadFunction(this.headers);
+    }
 
     Object.assign(wmtsOptions, this.openlayersOptions);
     return new Tile({

package/src/layer/pointCloudLayer.ts

@@ -1,4 +1,4 @@
-import { checkMaybe } from '@vcsuite/check';
+import { check, maybe, oneOf } from '@vcsuite/check';
 // eslint-disable-next-line import/no-named-default
 import type { default as OLStyle, StyleFunction } from 'ol/style/Style.js';
 import CesiumTilesetLayer, {
@@ -80,7 +80,7 @@ class PointCloudLayer extends CesiumTilesetLayer {
   }
 
   set pointSize(size: string | number | undefined) {
-    checkMaybe(size, [Number, String]);
+    check(size, maybe(oneOf(Number, String)));
     this._pointSize = size;
     (this.style as DeclarativeStyleItem).pointSize = size?.toString();
   }