@vcmap/core 6.0.7 → 6.1.0-rc.2

package/src/vectorCluster/vectorClusterStyleItem.ts

@@ -0,0 +1,490 @@
+import Style, { StyleFunction } from 'ol/style/Style.js';
+import Icon from 'ol/style/Icon.js';
+import Feature from 'ol/Feature.js';
+import { check, is, oneOf } from '@vcsuite/check';
+import { parseInteger, parseNumber } from '@vcsuite/parsers';
+import deepEqual from 'fast-deep-equal';
+import { originalFeatureSymbol } from '../layer/vectorSymbols.js';
+import { highlighted } from '../layer/featureVisibility.js';
+import VcsObject, { VcsObjectOptions } from '../vcsObject.js';
+import VcsEvent from '../vcsEvent.js';
+import type VectorLayer from '../layer/vectorLayer.js';
+import { renderTemplate } from '../util/vcsTemplate.js';
+import { vectorClusterGroupName } from './vectorClusterSymbols.js';
+import { vcsLayerName } from '../layer/layerSymbols.js';
+
+export type VectorClusterStyleItemOptions = VcsObjectOptions & {
+  template?: string | VectorClusterTemplateFunction;
+  fillColor?: string;
+  strokeColor?: string;
+  strokeWidth?: number;
+  textColor?: string;
+  font?: string;
+  breaks?: number[];
+  zeroScaleOffset?: number;
+  scaleFactor?: number;
+};
+
+export type VectorClusterTemplateFunction = (
+  styleItem: VectorClusterStyleItem,
+  feature: Feature[],
+  getLayerByName: (layerName: string) => VectorLayer | undefined,
+) => { template: string; cacheKey: string; context?: Record<string, unknown> };
+
+function createDefaultTemplateFunction(
+  template: string,
+): VectorClusterTemplateFunction {
+  return (styleItem, features) => ({
+    template,
+    cacheKey: String(styleItem.findBreakIndex(features.length)),
+  });
+}
+
+export default class VectorClusterStyleItem extends VcsObject {
+  static get className(): string {
+    return 'VectorClusterStyleItem';
+  }
+
+  static getDefaultOptions(): Required<VectorClusterStyleItemOptions> {
+    return {
+      type: 'VectorClusterStyleItem',
+      name: '',
+      properties: {},
+      template: [
+        '<svg width="64" height="64" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64">',
+        ' <defs><style>',
+        '  .cls-1 {',
+        '   fill: {{ fillColor }};',
+        '   stroke: {{ strokeColor }};',
+        '   stroke-miterlimit: 10;',
+        '   stroke-width: {{ strokeWidth }}px;',
+        ' }',
+        ' .text {',
+        '   font: {{ font }};',
+        '   fill: {{ textColor }};',
+        '   text-anchor: middle;',
+        '   alignment-baseline: middle;',
+        '   dominant-baseline: middle;',
+        ' }',
+        ' </style></defs>',
+        ' <circle id="outer" class="cls-1" cx="32" cy="32" r="30"/>',
+        ' <text x="32" y="32" class="text">',
+        '   {{ text }}',
+        ' </text>',
+        '</svg>',
+      ].join(''),
+      fillColor: '#ffffff',
+      strokeColor: '#2a2a2a',
+      strokeWidth: 4,
+      textColor: '#2a2a2a',
+      font: 'normal normal 700 32px Calibri-Bold,Calibri',
+      breaks: [2, 3, 4, 5, 10, 15, 20, 25],
+      zeroScaleOffset: 3,
+      scaleFactor: 0.08,
+    };
+  }
+
+  private _template: string | VectorClusterTemplateFunction = '';
+
+  private _templateFunction: VectorClusterTemplateFunction =
+    createDefaultTemplateFunction('');
+
+  private _breaks: number[] = [];
+
+  private _zeroScaleOffset: number;
+
+  private _fillColor: string;
+
+  private _strokeColor: string;
+
+  private _strokeWidth: number;
+
+  private _textColor: string;
+
+  private _font: string;
+
+  private _scaleFactor: number;
+
+  private _styleCache = new Map<string, Style>();
+
+  styleChanged = new VcsEvent<void>();
+
+  constructor(options: VectorClusterStyleItemOptions) {
+    super(options);
+    const defaultOptions = VectorClusterStyleItem.getDefaultOptions();
+
+    const configTemplate = Array.isArray(options.template)
+      ? options.template.join('')
+      : options.template;
+
+    this.setTemplate(configTemplate ?? defaultOptions.template);
+    this._breaks = options.breaks?.slice() ?? defaultOptions.breaks;
+    this._zeroScaleOffset = parseInteger(
+      options.zeroScaleOffset,
+      defaultOptions.zeroScaleOffset,
+    );
+    this._fillColor = options.fillColor ?? defaultOptions.fillColor;
+    this._strokeColor = options.strokeColor ?? defaultOptions.strokeColor;
+    this._strokeWidth = parseNumber(
+      options.strokeWidth,
+      defaultOptions.strokeWidth,
+    );
+    this._textColor = options.textColor ?? defaultOptions.textColor;
+    this._font = options.font ?? defaultOptions.font;
+    this._scaleFactor = parseNumber(
+      options.scaleFactor,
+      defaultOptions.scaleFactor,
+    );
+
+    this.styleChanged.addEventListener(() => {
+      this.clearCache();
+    });
+  }
+
+  /**
+   * An array of cluster sizes to break at. Typically the first couple of sizes are
+   * a series (meaning: not grouped). Later breaks are non sequential and used for grouping
+   * clusters larger. [2, 3, 4, 5, 10] would start grouping at clusters larger or equal 5
+   * entries.
+   */
+  get breaks(): number[] {
+    return this._breaks.slice();
+  }
+
+  set breaks(breaks: number[]) {
+    check(breaks, [Number]);
+
+    const sortedBreaks = breaks.sort((a, b) => (a < b ? -1 : 1));
+    const changed = sortedBreaks.find((b, i) => b !== this._breaks[i]);
+    if (changed) {
+      this._breaks = breaks;
+      this.styleChanged.raiseEvent();
+    }
+  }
+
+  /**
+   * The index of breaks to st. for indexes [2, 3, 4, 5, 10] and a zeroScale offset of 3
+   * would lead to icons 2, 3, 4 having the same size and no "+" attached. 5 and 10
+   * would be scaled by the scale factor and a "+" added to the text
+   */
+  get zeroScaleOffset(): number {
+    return this._zeroScaleOffset;
+  }
+
+  set zeroScaleOffset(zeroScaleOffset: number) {
+    check(zeroScaleOffset, Number);
+
+    if (zeroScaleOffset !== this._zeroScaleOffset) {
+      this._zeroScaleOffset = zeroScaleOffset;
+      this.styleChanged.raiseEvent();
+    }
+  }
+
+  /**
+   * The fill color. This must be a css string.
+   */
+  get fillColor(): string {
+    return this._fillColor;
+  }
+
+  set fillColor(fillColor: string) {
+    check(fillColor, String);
+
+    if (fillColor !== this._fillColor) {
+      this._fillColor = fillColor;
+      this.styleChanged.raiseEvent();
+    }
+  }
+
+  /**
+   * The stroke color. This must be a css string.
+   */
+  get strokeColor(): string {
+    return this._strokeColor;
+  }
+
+  set strokeColor(strokeColor: string) {
+    check(strokeColor, String);
+
+    if (strokeColor !== this._strokeColor) {
+      this._strokeColor = strokeColor;
+      this.styleChanged.raiseEvent();
+    }
+  }
+
+  /**
+   * The stroke color. This must be a css string.
+   */
+  get strokeWidth(): number {
+    return this._strokeWidth;
+  }
+
+  set strokeWidth(strokeWidth: number) {
+    check(strokeWidth, Number);
+
+    if (strokeWidth !== this._strokeWidth) {
+      this._strokeWidth = strokeWidth;
+      this.styleChanged.raiseEvent();
+    }
+  }
+
+  /**
+   * The text color. This must be a css string.
+   */
+  get textColor(): string {
+    return this._textColor;
+  }
+
+  set textColor(textColor: string) {
+    check(textColor, String);
+
+    if (textColor !== this._textColor) {
+      this._textColor = textColor;
+      this.styleChanged.raiseEvent();
+    }
+  }
+
+  /**
+   * The font to use. Must be css font attribute.
+   */
+  get font(): string {
+    return this._font;
+  }
+
+  set font(font: string) {
+    check(font, String);
+
+    if (font !== this._font) {
+      this._font = font;
+      this.styleChanged.raiseEvent();
+    }
+  }
+
+  /**
+   * The factor by which to multiply the index of the used break grouping
+   * (subtracted by the zeroScaleOffset)
+   */
+  get scaleFactor(): number {
+    return this._scaleFactor;
+  }
+
+  set scaleFactor(scaleFactor: number) {
+    check(scaleFactor, Number);
+
+    if (scaleFactor !== this._scaleFactor) {
+      this._scaleFactor = scaleFactor;
+      this.styleChanged.raiseEvent();
+    }
+  }
+
+  get template(): string | VectorClusterTemplateFunction {
+    return this._template;
+  }
+
+  setTemplate(template: string | VectorClusterTemplateFunction): void {
+    check(template, oneOf(String, Function));
+
+    if (template !== this._template) {
+      this._template = template;
+      if (is(this._template, String)) {
+        this._templateFunction = createDefaultTemplateFunction(this._template);
+      } else {
+        this._templateFunction = this._template;
+      }
+      this.styleChanged.raiseEvent();
+    }
+  }
+
+  /**
+   * Finds the breaks index of a specified cluster size.
+   */
+  findBreakIndex(size: number): number {
+    const clusterTextIndex = this._breaks.findIndex((classBreak, i) =>
+      i > this._zeroScaleOffset ? size < classBreak : size <= classBreak,
+    );
+
+    return clusterTextIndex === -1 ? this._breaks.length : clusterTextIndex;
+  }
+
+  /**
+   * Gets the cluster text based on breaks and zeroScaleOffset. Adds a + to all sizes with an index larger then the zeroScaleOffset.
+   */
+  getClusterText(size: number): string {
+    if (size === 1) {
+      return '';
+    }
+    const clusterTextIndex = this.findBreakIndex(size);
+    let clusterText =
+      this._breaks[
+        clusterTextIndex > this._zeroScaleOffset
+          ? clusterTextIndex - 1
+          : clusterTextIndex
+      ].toString();
+    if (clusterTextIndex > this._zeroScaleOffset) {
+      clusterText = `${clusterText}+`;
+    }
+
+    return clusterText;
+  }
+
+  /**
+   * Determines the scale based on break index and zeroScaleOffset. Cluster sizes with an index less then zeroScaleOffset
+   * are not scaled.
+   */
+  determineScale(size: number): number {
+    const index = this.findBreakIndex(size);
+
+    let indexScale = index - this._zeroScaleOffset;
+    indexScale = indexScale > 0 ? indexScale : 0;
+    return 0.6 + this._scaleFactor * indexScale;
+  }
+
+  createStyleFunction(
+    getLayerByName: (layerName: string) => VectorLayer | undefined,
+  ): StyleFunction {
+    const styleFunction = (
+      feature: Feature,
+      resolution: number,
+    ): Style | undefined => {
+      let features: Feature[] = [feature];
+      if (feature[vectorClusterGroupName]) {
+        features = (feature.get('features') as Feature[]) ?? [feature];
+      }
+      const size = features.length;
+      if (size > 1) {
+        const { template, cacheKey, context } = this._templateFunction(
+          this,
+          features,
+          getLayerByName,
+        );
+        if (!this._styleCache.has(cacheKey)) {
+          try {
+            const src = `data:image/svg+xml,${encodeURIComponent(
+              renderTemplate(template, {
+                // XXX document what parameters are past to the object
+                text: this.getClusterText(size),
+                fillColor: this._fillColor,
+                strokeColor: this._strokeColor,
+                strokeWidth: this._strokeWidth,
+                textColor: this._textColor,
+                font: this._font,
+                size,
+                ...context,
+              }),
+            )}`;
+            const scale = this.determineScale(size);
+            this._styleCache.set(
+              cacheKey,
+              new Style({
+                image: new Icon({
+                  src,
+                  scale,
+                  anchor: [0.5, 0.5], // XXX make configurable?
+                  size: [64, 64], // XXX make configurable?
+                }),
+              }),
+            );
+          } catch (e) {
+            this.getLogger().error('Error creating cluster style', e);
+            this._styleCache.set(cacheKey, new Style({}));
+          }
+        }
+        return this._styleCache.get(cacheKey)!;
+      } else if (size === 1) {
+        const singleFeature = features[0][originalFeatureSymbol] || features[0];
+        if (singleFeature[vcsLayerName]) {
+          const layer = getLayerByName(singleFeature[vcsLayerName]);
+
+          let style =
+            singleFeature[highlighted]?.style ?? singleFeature.getStyle();
+          if (!style && layer) {
+            ({ style } = layer.style);
+          }
+          if (style instanceof Style) {
+            return style;
+          }
+
+          if (typeof style === 'function') {
+            return style(singleFeature, resolution) as Style;
+          }
+        }
+      }
+
+      return undefined;
+    };
+
+    return styleFunction as StyleFunction;
+  }
+
+  /**
+   * Clears the style cache to ensure new changes can take effect.
+   * @api
+   */
+  clearCache(): void {
+    this._styleCache.clear();
+  }
+
+  toJSON(): VectorClusterStyleItemOptions {
+    const config: Partial<VectorClusterStyleItemOptions> = super.toJSON();
+    const defaultOptions = VectorClusterStyleItem.getDefaultOptions();
+    if (this.template !== defaultOptions.template) {
+      config.template = this.template;
+    }
+    if (this.fillColor !== defaultOptions.fillColor) {
+      config.fillColor = this.fillColor;
+    }
+    if (this.strokeColor !== defaultOptions.strokeColor) {
+      config.strokeColor = this.strokeColor;
+    }
+    if (this.strokeWidth !== defaultOptions.strokeWidth) {
+      config.strokeWidth = this.strokeWidth;
+    }
+    if (this.textColor !== defaultOptions.textColor) {
+      config.textColor = this.textColor;
+    }
+    if (this.font !== defaultOptions.font) {
+      config.font = this.font;
+    }
+    const { breaks } = this;
+    if (
+      breaks.length !== defaultOptions.breaks.length ||
+      breaks.some((b) => !defaultOptions.breaks.includes(b))
+    ) {
+      config.breaks = breaks;
+    }
+    if (this.zeroScaleOffset !== defaultOptions.zeroScaleOffset) {
+      config.zeroScaleOffset = this.zeroScaleOffset;
+    }
+    if (this.scaleFactor !== defaultOptions.scaleFactor) {
+      config.scaleFactor = this.scaleFactor;
+    }
+
+    return config;
+  }
+
+  equals(other: VectorClusterStyleItem): boolean {
+    const thisJson = this.toJSON();
+    delete thisJson.name;
+
+    const otherJson = other.toJSON();
+    delete otherJson.name;
+
+    return deepEqual(thisJson, otherJson);
+  }
+
+  destroy(): void {
+    this.clearCache();
+    this.styleChanged.destroy();
+    super.destroy();
+  }
+}
+
+export function getDefaultClusterStyleItem(): VectorClusterStyleItem {
+  return new VectorClusterStyleItem({});
+}
+
+export function getDefaultClusterHighlightStyleItem(): VectorClusterStyleItemOptions {
+  return new VectorClusterStyleItem({
+    fillColor: '#409D76',
+  });
+}

package/src/vectorCluster/vectorClusterSymbols.ts

@@ -0,0 +1,2 @@
+// eslint-disable-next-line import/prefer-default-export
+export const vectorClusterGroupName = Symbol('vectorClusterGroupName');

package/dist/src/layer/cesium/clusterContext.d.ts

@@ -1,20 +0,0 @@
-import { CustomDataSource, EntityCollection, SplitDirection, Scene } from '@vcmap-cesium/engine';
-import { StyleLike } from 'ol/style/Style.js';
-import type { Feature } from 'ol/index.js';
-import { CesiumVectorContext } from './vectorContext.js';
-import VectorProperties from '../vectorProperties.js';
-declare class ClusterContext implements CesiumVectorContext {
-    entities: EntityCollection;
-    splitDirection: SplitDirection;
-    private _splitDirectionProperty;
-    private _featureItems;
-    private _convertingFeatures;
-    constructor(dataSource: CustomDataSource, splitDirection: SplitDirection);
-    private _addConvertedItems;
-    addFeature(feature: Feature, style: StyleLike, vectorProperties: VectorProperties, scene: Scene): Promise<void>;
-    removeFeature(feature: Feature): void;
-    updateSplitDirection(splitDirection: SplitDirection): void;
-    clear(): void;
-    destroy(): void;
-}
-export default ClusterContext;

package/dist/src/layer/cesium/clusterContext.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"clusterContext.js","sourceRoot":"","sources":["../../../../src/layer/cesium/clusterContext.ts"],"names":[],"mappings":"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"}

package/src/layer/cesium/clusterContext.ts

@@ -1,140 +0,0 @@
-import {
-  CustomDataSource,
-  EntityCollection,
-  Entity,
-  SplitDirection,
-  Scene,
-  ConstantProperty,
-} from '@vcmap-cesium/engine';
-import { StyleLike } from 'ol/style/Style.js';
-import type { Feature } from 'ol/index.js';
-import {
-  CesiumVectorContext,
-  setReferenceForPicking,
-} from './vectorContext.js';
-import VectorProperties from '../vectorProperties.js';
-import convert, { ConvertedItem } from '../../util/featureconverter/convert.js';
-
-class ClusterContext implements CesiumVectorContext {
-  entities: EntityCollection;
-
-  splitDirection: SplitDirection;
-
-  private _splitDirectionProperty: ConstantProperty;
-
-  private _featureItems = new Map<Feature, (() => void)[]>();
-
-  private _convertingFeatures: Map<Feature, () => void> = new Map();
-
-  constructor(dataSource: CustomDataSource, splitDirection: SplitDirection) {
-    this.entities = dataSource.entities;
-    this.splitDirection = splitDirection;
-    this._splitDirectionProperty = new ConstantProperty(splitDirection);
-  }
-
-  private _addConvertedItems(
-    feature: Feature,
-    allowPicking: boolean,
-    items: ConvertedItem[],
-  ): void {
-    const removeItems = items
-      .map((item) => {
-        let instance: Entity | undefined;
-        let removeItem: (() => void) | undefined;
-        if (item.type === 'billboard') {
-          instance = this.entities.add({
-            billboard: {
-              ...item.item,
-              splitDirection: this._splitDirectionProperty,
-            },
-            position: item.item.position,
-          });
-        } else if (item.type === 'label') {
-          instance = this.entities.add({
-            label: item.item,
-            position: item.item.position,
-          });
-        }
-
-        if (instance) {
-          removeItem = (): void => {
-            this.entities.remove(instance);
-          };
-        }
-
-        if (instance) {
-          if (allowPicking) {
-            setReferenceForPicking(feature, instance);
-          }
-        }
-        return removeItem;
-      })
-      .filter((i): i is () => void => i != null);
-
-    this._featureItems.set(feature, removeItems);
-  }
-
-  async addFeature(
-    feature: Feature,
-    style: StyleLike,
-    vectorProperties: VectorProperties,
-    scene: Scene,
-  ): Promise<void> {
-    this._convertingFeatures.get(feature)?.();
-    let deleted = false;
-    this._convertingFeatures.set(feature, () => {
-      deleted = true;
-    });
-
-    const convertedItems = await convert(
-      feature,
-      style,
-      vectorProperties,
-      scene,
-    );
-
-    this._featureItems.get(feature)?.forEach((removeItem) => removeItem());
-
-    if (deleted) {
-      convertedItems.forEach((item) => {
-        if (item.type === 'primitive') {
-          item.item.destroy();
-        }
-      });
-    } else {
-      this._addConvertedItems(
-        feature,
-        vectorProperties.getAllowPicking(feature),
-        convertedItems,
-      );
-    }
-  }
-
-  removeFeature(feature: Feature): void {
-    this._convertingFeatures.get(feature)?.();
-    this._convertingFeatures.delete(feature);
-    this._featureItems.get(feature)?.forEach((removeItem) => removeItem());
-    this._featureItems.delete(feature);
-  }
-
-  // eslint-disable-next-line class-methods-use-this,no-unused-vars
-  updateSplitDirection(splitDirection: SplitDirection): void {
-    this.splitDirection = splitDirection;
-    this._splitDirectionProperty.setValue(this.splitDirection);
-  }
-
-  clear(): void {
-    this.entities.removeAll();
-    this._featureItems.clear();
-    this._convertingFeatures.forEach((destroy) => {
-      destroy();
-    });
-    this._convertingFeatures.clear();
-  }
-
-  destroy(): void {
-    this.clear();
-  }
-}
-
-export default ClusterContext;

package/src/ol/source/VcsCluster.js

@@ -1,37 +0,0 @@
-import Cluster from 'ol/source/Cluster.js';
-
-/**
- * @class
- * @extends {import("ol/source/Cluster").default}
- * @memberOf ol
- */
-class VcsCluster extends Cluster {
-  constructor(props) {
-    super(props);
-    /**
-     * @type {boolean}
-     */
-    this._paused = false;
-  }
-
-  pause() {
-    this._paused = true;
-  }
-
-  resume() {
-    this._paused = false;
-  }
-
-  isPaused() {
-    return this._paused;
-  }
-
-  refresh() {
-    if (this._paused) {
-      return;
-    }
-    super.refresh();
-  }
-}
-
-export default VcsCluster;