@vcmap/core 6.0.7 → 6.1.0-rc.2

package/src/util/vcsTemplate.ts

@@ -0,0 +1,373 @@
+import {
+  BooleanType,
+  newParsingContext,
+  StringType,
+  NoneType,
+  LiteralValue,
+} from 'ol/expr/expression.js';
+import { buildExpression, newEvaluationContext } from 'ol/expr/cpu.js';
+import { is } from '@vcsuite/check';
+
+type Block = {
+  opening: RegExpExecArray;
+  closing: RegExpExecArray;
+};
+
+type ConditionalBlock = Block & {
+  elseStatement?: RegExpExecArray;
+  elseIfs: RegExpExecArray[];
+};
+
+/**
+ * @param {string} expressionString
+ * @param {Record<string, unknown>} data
+ * @param {number} evaluationType
+ * @returns {*}
+ */
+function evaluateExpression(
+  expressionString: string,
+  data: Record<string, unknown>,
+  evaluationType: number,
+): LiteralValue {
+  const parsed = expressionString.startsWith('[')
+    ? (JSON.parse(expressionString) as any[])
+    : [
+        'get',
+        ...expressionString
+          .replace(/\[([^\]]+)]/g, '.$1')
+          .split('.')
+          .filter((f) => f),
+      ];
+
+  const compiledExpression = buildExpression(
+    parsed,
+    evaluationType,
+    newParsingContext(),
+  );
+  const evaluationContext = newEvaluationContext();
+  evaluationContext.properties = data;
+  return compiledExpression(evaluationContext);
+}
+
+/**
+ * Replaces template strings by provided attributes, e.g. {{myAttribute}}
+ */
+function replaceAttributes(
+  template: string,
+  data: Record<string, unknown>,
+): string {
+  const pattern = /\{\{([^}]+)}}/g;
+  return template.replace(pattern, (_p, value) => {
+    return (
+      (evaluateExpression(
+        (value as string).trim(),
+        data,
+        StringType,
+      ) as string) ?? ''
+    );
+  });
+}
+
+function regexHits(regexp: RegExp, string: string): RegExpExecArray[] {
+  const hits = [];
+  let hit;
+  // eslint-disable-next-line no-cond-assign
+  while ((hit = regexp.exec(string))) {
+    hits.push(hit);
+  }
+
+  return hits;
+}
+
+function findTopLevelBlock(
+  openings: RegExpExecArray[],
+  closings: RegExpExecArray[],
+  accepted: (b: Block) => void,
+  rejected: (b: Block) => void,
+): void {
+  const localOpenings = openings.slice();
+  const localClosings = closings.slice();
+  while (localOpenings.length > 0) {
+    let matchingClosing;
+    let matchingOpening;
+    while (!matchingClosing && localClosings.length > 0) {
+      const currentClosing = localClosings.shift()!;
+      const openingDistances = localOpenings.map(
+        (o) => currentClosing.index - o.index,
+      );
+      const minDistance = openingDistances.reduce((min, currentDistance) => {
+        if (currentDistance > 0 && currentDistance < min) {
+          return currentDistance;
+        }
+        return min;
+      }, Infinity);
+      const matchingOpeningIndex = openingDistances.indexOf(minDistance);
+      matchingOpening = localOpenings[matchingOpeningIndex];
+
+      if (matchingOpeningIndex === 0) {
+        matchingClosing = currentClosing;
+      } else {
+        rejected({ opening: matchingOpening, closing: currentClosing });
+      }
+      localOpenings.splice(matchingOpeningIndex, 1);
+    }
+
+    if (matchingOpening && matchingClosing) {
+      accepted({ opening: matchingOpening, closing: matchingClosing });
+    }
+  }
+}
+
+function tagWithinBlock(tag: RegExpExecArray, block: Block): boolean {
+  return tag.index > block.opening.index && tag.index < block.closing.index;
+}
+
+function getForEachBlocks(template: string): Block[] {
+  const forEachBlocks = [] as Block[];
+  const forEachOpenings = regexHits(
+    /\s*{{#each\s\(([^.)]+)\)\sin\s([^}]+)}}\s*/g,
+    template,
+  );
+  const forEachClosings = regexHits(/\s*{{\/each}}\s*/g, template);
+
+  if (forEachClosings.length > forEachOpenings.length) {
+    throw new Error(
+      'Template failed to render, missing opening tag for each statements',
+    );
+  } else if (forEachClosings.length < forEachOpenings.length) {
+    throw new Error(
+      'Template failed to render, missing closing tag for each statements',
+    );
+  }
+
+  findTopLevelBlock(
+    forEachOpenings,
+    forEachClosings,
+    (block) => {
+      forEachBlocks.push(block);
+    },
+    () => {},
+  );
+
+  return forEachBlocks;
+}
+
+function getConditionalBlocks(
+  template: string,
+  forEachBlocks: Block[],
+): ConditionalBlock[] {
+  const conditionalBlocks = [] as ConditionalBlock[];
+  let conditionalOpenings = regexHits(/\s*{{#if\s([^}]*)}}\s*/g, template);
+  let conditionalClosings = regexHits(/\s*{{\/if}}\s*/g, template);
+  let elseIfs = regexHits(/\s*{{elseif\s([^}]*)}}\s*/g, template);
+  let elses = regexHits(/\s*{{else}}\s*/g, template);
+
+  const withinForEachBlock = (tag: RegExpExecArray): Block | undefined =>
+    forEachBlocks.find((block) => tagWithinBlock(tag, block));
+
+  // conditionals within a for each blocks are rendered with the for each block, ignore
+  conditionalOpenings = conditionalOpenings.filter(
+    (t) => !withinForEachBlock(t),
+  );
+  conditionalClosings = conditionalClosings.filter(
+    (t) => !withinForEachBlock(t),
+  );
+
+  if (conditionalClosings.length > conditionalOpenings.length) {
+    throw new Error(
+      'Template failed to render, missing closing tag for if statements',
+    );
+  } else if (conditionalClosings.length < conditionalOpenings.length) {
+    throw new Error(
+      'Template failed to render, missing opening tag for if statements',
+    );
+  }
+
+  const filterElseIfElse = (block: Block): void => {
+    elseIfs = elseIfs.filter((tag) => !tagWithinBlock(tag, block));
+    elses = elses.filter((tag) => !tagWithinBlock(tag, block));
+  };
+
+  findTopLevelBlock(
+    conditionalOpenings,
+    conditionalClosings,
+    (block) => {
+      const blockElseIfs = elseIfs.filter((tag) => tagWithinBlock(tag, block));
+      const elseStatement = elses.find((tag) => tagWithinBlock(tag, block));
+      if (
+        elseStatement &&
+        blockElseIfs.length > 0 &&
+        elseStatement.index < blockElseIfs.at(-1)!.index
+      ) {
+        throw new Error('{{else}} must be the last entry in a block');
+      }
+      conditionalBlocks.push({
+        ...block,
+        elseStatement,
+        elseIfs: blockElseIfs,
+      });
+    },
+    (block) => {
+      filterElseIfElse(block);
+    },
+  );
+
+  return conditionalBlocks;
+}
+
+function shouldRemoveWhiteSpace(openingTag: string): boolean {
+  return /\n\s*\{/.test(openingTag) && /}\s*\n/.test(openingTag);
+}
+
+/**
+ * This will extract the block to render separately. This will depend on the white space handling. If the
+ * opening is placed on its own line, whitespace after the opening and before the closing blocks will be removed
+ * from the sub template, up to the first new line feed.
+ */
+function getSubTemplateForBlock(template: string, block: Block): string {
+  const removeWhiteSpace = shouldRemoveWhiteSpace(block.opening[0]);
+  let startIndex = block.opening.index + block.opening[0].indexOf('}') + 2;
+  let endIndex = block.closing.index + block.closing[0].indexOf('{');
+  if (removeWhiteSpace) {
+    startIndex += (/}\s*\n/.exec(block.opening[0])?.[0].length ?? 1) - 1;
+    endIndex -= (/\n\s*\{/.exec(block.closing[0])?.[0].length ?? 2) - 2;
+  }
+
+  return template.substring(startIndex, endIndex);
+}
+
+/**
+ * This will replace a block with a previously extracted blocks rendered template.
+ * This will depend on the white space handling. If the opening is placed on its own line,
+ * whitespace before the opening and after the closing blocks will be removed up to the first new line feed,
+ * from the new template string all together.
+ */
+function replaceBlock(
+  template: string,
+  block: Block,
+  replacement: string,
+): string {
+  const removeWhiteSpace = shouldRemoveWhiteSpace(block.opening[0]);
+  let startIndex = block.opening.index + block.opening[0].indexOf('{');
+  let endIndex = block.closing.index + block.closing[0].indexOf('}') + 2;
+  if (removeWhiteSpace) {
+    startIndex -= (/\n\s*\{/.exec(block.opening[0])?.[0].length ?? 2) - 2;
+    endIndex += (/}\s*\n/.exec(block.closing[0])?.[0].length ?? 1) - 1;
+  }
+
+  return `${template.substring(
+    0,
+    startIndex,
+  )}${replacement}${template.substring(endIndex)}`;
+}
+
+/**
+ * Replaces {{#if }} blocks
+ */
+function expandConditionalsAndLoops(
+  template: string,
+  data: Record<string, unknown>,
+): string {
+  let renderedTemplate = template;
+  const forEachBlocks = getForEachBlocks(template);
+
+  getConditionalBlocks(template, forEachBlocks)
+    .reverse()
+    .forEach(
+      /** @param {ConditionalBlock} block */ (block) => {
+        const partialBlocks = [block.opening];
+        if (block.elseIfs) {
+          partialBlocks.push(...block.elseIfs);
+        }
+        let trueStatementIndex = partialBlocks.findIndex((s) =>
+          evaluateExpression(s[1].trim(), data, BooleanType),
+        );
+        if (trueStatementIndex === -1 && block.elseStatement) {
+          trueStatementIndex = partialBlocks.length;
+        }
+
+        let renderedBlock = '';
+        if (trueStatementIndex > -1) {
+          if (block.elseStatement) {
+            partialBlocks.push(block.elseStatement);
+          }
+          partialBlocks.push(block.closing);
+
+          const blockTemplate = getSubTemplateForBlock(template, {
+            opening: partialBlocks[trueStatementIndex],
+            closing: partialBlocks[trueStatementIndex + 1],
+          });
+
+          renderedBlock = expandConditionalsAndLoops(blockTemplate, data);
+        }
+
+        renderedTemplate = replaceBlock(renderedTemplate, block, renderedBlock);
+      },
+    );
+
+  // only iterate over blocks not removed by conditionals
+  getForEachBlocks(renderedTemplate)
+    .reverse()
+    .forEach((block) => {
+      const obj = evaluateExpression(block.opening[2].trim(), data, NoneType);
+      let keyValuePairs;
+      if (is(obj, Object)) {
+        keyValuePairs = Object.entries(obj);
+      } else if (Array.isArray(obj)) {
+        keyValuePairs = obj.entries();
+      }
+      const renderedBlocks = [];
+      if (keyValuePairs) {
+        let index = 0;
+        const [valueName, keyName, indexName] = block.opening[1]
+          .split(',')
+          .map((e) => e.trim())
+          .slice(0, 3);
+
+        const blockTemplate = getSubTemplateForBlock(renderedTemplate, block);
+        // eslint-disable-next-line no-restricted-syntax
+        for (const args of keyValuePairs) {
+          const forEachData = structuredClone(data);
+          forEachData[valueName] = args[1];
+          if (keyName) {
+            forEachData[keyName] = args[0];
+          }
+          if (indexName) {
+            forEachData[indexName] = index;
+          }
+          const currentBlock = expandConditionalsAndLoops(
+            blockTemplate,
+            forEachData,
+          );
+          renderedBlocks.push(replaceAttributes(currentBlock, forEachData));
+          index += 1;
+        }
+      }
+
+      renderedTemplate = replaceBlock(
+        renderedTemplate,
+        block,
+        renderedBlocks.join(''),
+      );
+    });
+
+  return renderedTemplate;
+}
+
+/**
+ * Renders a template in these steps. See {@link documentation/vcsTemplate.md} for more information.
+ * 1. expand conditional blocks. this will remove any blocks that do not match their expressions and choose from if / elseif / else block which of them to render
+ * 2. expand iterations. this will create new templates for each iteration and re-run the rendering for those blocks
+ * 3. render attributes. this will add the attributes to all the blocks not within each blocks
+ */
+// eslint-disable-next-line import/prefer-default-export
+export function renderTemplate(
+  template: string | string[],
+  data: Record<string, unknown>,
+): string {
+  const templateString = Array.isArray(template)
+    ? template.join('\n')
+    : template;
+  const conditionalTemplate = expandConditionalsAndLoops(templateString, data);
+  return replaceAttributes(conditionalTemplate, data);
+}

package/src/vcsApp.ts

@@ -52,6 +52,12 @@ import FlightInstance, {
 } from './util/flight/flightInstance.js';
 import FlightCollection from './util/flight/flightCollection.js';
 import DisplayQuality from './util/displayQuality/displayQuality.js';
+import VectorClusterGroup from './vectorCluster/vectorClusterGroup.js';
+import VectorClusterGroupCollection from './vectorCluster/vectorClusterGroupCollection.js';
+import ClippingPolygonObject, {
+  ClippingPolygonObjectOptions,
+} from './util/clipping/clippingPolygonObject.js';
+import ClippingPolygonObjectCollection from './util/clipping/clippingPolygonObjectCollection.js';
 
 function getLogger(): Logger {
   return getLoggerByName('init');
@@ -104,6 +110,11 @@ class VcsApp {
 
   private _layers: OverrideCollection<Layer, LayerCollection>;
 
+  private _vectorClusterGroups: OverrideCollection<
+    VectorClusterGroup,
+    VectorClusterGroupCollection
+  >;
+
   private _obliqueCollections: OverrideCollection<ObliqueCollection>;
 
   private _viewpoints: OverrideCollection<Viewpoint>;
@@ -116,6 +127,8 @@ class VcsApp {
 
   private _hiddenObjects: OverrideCollection<HiddenObject>;
 
+  private _clippingPolygons: OverrideCollection<ClippingPolygonObject>;
+
   private _flights: OverrideCollection<FlightInstance, FlightCollection>;
 
   private _categoryClassRegistry: OverrideClassRegistry<
@@ -183,6 +196,14 @@ class VcsApp {
     );
     this._layers.locale = this.locale;
 
+    this._vectorClusterGroups = makeOverrideCollection(
+      this._layers.vectorClusterGroups,
+      getDynamicModuleId,
+      undefined,
+      (config) => new VectorClusterGroup(config),
+      VectorClusterGroup,
+    );
+
     this._obliqueCollections = makeOverrideCollection(
       new Collection(),
       getDynamicModuleId,
@@ -217,6 +238,14 @@ class VcsApp {
       this._layers.globalHider,
     );
 
+    this._clippingPolygons = makeOverrideCollection(
+      new ClippingPolygonObjectCollection(this),
+      getDynamicModuleId,
+      undefined,
+      (clippingPolygonOptions: ClippingPolygonObjectOptions) =>
+        new ClippingPolygonObject(clippingPolygonOptions),
+    );
+
     this._flights = makeOverrideCollection(
       new FlightCollection(this),
       getDynamicModuleId,
@@ -286,6 +315,13 @@ class VcsApp {
     return this._layers;
   }
 
+  get vectorClusterGroups(): OverrideCollection<
+    VectorClusterGroup,
+    VectorClusterGroupCollection
+  > {
+    return this._vectorClusterGroups;
+  }
+
   get obliqueCollections(): OverrideCollection<ObliqueCollection> {
     return this._obliqueCollections;
   }
@@ -306,6 +342,10 @@ class VcsApp {
     return this._hiddenObjects;
   }
 
+  get clippingPolygons(): OverrideCollection<ClippingPolygonObject> {
+    return this._clippingPolygons;
+  }
+
   get flights(): OverrideCollection<FlightInstance, FlightCollection> {
     return this._flights;
   }
@@ -383,6 +423,10 @@ class VcsApp {
 
     await this._styles.parseItems(config.styles, module._id);
     await this._layers.parseItems(config.layers, module._id);
+    await this._vectorClusterGroups.parseItems(
+      config.vectorClusterGroups,
+      module._id,
+    );
     // TODO add ade here
 
     await this._obliqueCollections.parseItems(
@@ -392,6 +436,10 @@ class VcsApp {
     await this._viewpoints.parseItems(config.viewpoints, module._id);
     await this._maps.parseItems(config.maps, module._id);
     await this._hiddenObjects.parseItems(config.hiddenObjects, module._id);
+    await this._clippingPolygons.parseItems(
+      config.clippingPolygons,
+      module._id,
+    );
     await this._flights.parseItems(config.flights, module._id);
 
     if (Array.isArray(config.categories)) {
@@ -418,6 +466,14 @@ class VcsApp {
         }
       });
 
+    [...this._clippingPolygons]
+      .filter((c) => c[moduleIdSymbol] === module._id)
+      .forEach((c) => {
+        if (c.activeOnStartup) {
+          c.activate();
+        }
+      });
+
     if (config.startingObliqueCollectionName) {
       const startingObliqueCollection = this._obliqueCollections.getByKey(
         config.startingObliqueCollectionName,
@@ -516,6 +572,8 @@ class VcsApp {
     const config = this._modules.getByKey(moduleId)!.toJSON();
     config.maps = this._maps.serializeModule(moduleId);
     config.layers = this._layers.serializeModule(moduleId);
+    config.vectorClusterGroups =
+      this._vectorClusterGroups.serializeModule(moduleId);
     config.obliqueCollections =
       this._obliqueCollections.serializeModule(moduleId);
     config.viewpoints = this._viewpoints.serializeModule(moduleId);
@@ -523,6 +581,9 @@ class VcsApp {
     config.hiddenObjects = this._hiddenObjects.serializeModule(
       moduleId,
     ) as HiddenObject[];
+    config.clippingPolygons = this._clippingPolygons.serializeModule(
+      moduleId,
+    ) as ClippingPolygonObjectOptions[];
     config.flights = this._flights.serializeModule(moduleId);
     config.categories = [...this._categories]
       .map((c) => c.serializeModule(moduleId))
@@ -562,7 +623,9 @@ class VcsApp {
       this._styles.removeModule(moduleId),
       this._obliqueCollections.removeModule(moduleId),
       this._hiddenObjects.removeModule(moduleId),
+      this._clippingPolygons.removeModule(moduleId),
       this._flights.removeModule(moduleId),
+      this._vectorClusterGroups.removeModule(moduleId),
     ]);
   }
 
@@ -603,8 +666,10 @@ class VcsApp {
     destroyCollection(this._layers);
     destroyCollection(this._obliqueCollections);
     destroyCollection(this._viewpoints);
+    destroyCollection(this._flights);
     destroyCollection(this._styles);
     destroyCollection(this._categories);
+    destroyCollection(this._clippingPolygons);
     this._modules.destroy();
     this._hiddenObjects.destroy();
     this._mapClassRegistry.destroy();

package/src/vcsModule.ts

@@ -7,8 +7,10 @@ import type { ViewpointOptions } from './util/viewpoint.js';
 import type { ObliqueCollectionOptions } from './oblique/obliqueCollection.js';
 import type VcsApp from './vcsApp.js';
 import { moduleIdSymbol } from './moduleIdSymbol.js';
-import { HiddenObject } from './util/hiddenObjects.js';
-import { FlightInstanceOptions } from './util/flight/flightInstance.js';
+import type { HiddenObject } from './util/hiddenObjects.js';
+import type { FlightInstanceOptions } from './util/flight/flightInstance.js';
+import type { VectorClusterGroupOptions } from './vectorCluster/vectorClusterGroup.js';
+import type { ClippingPolygonObjectOptions } from './util/clipping/clippingPolygonObject.js';
 
 export type VcsModuleConfig = {
   _id?: string;
@@ -16,6 +18,7 @@ export type VcsModuleConfig = {
   description?: string | null;
   properties?: Record<string, unknown>;
   layers?: LayerOptions[];
+  vectorClusterGroups?: VectorClusterGroupOptions[];
   maps?: VcsMapOptions[];
   styles?: StyleItemOptions[];
   viewpoints?: ViewpointOptions[];
@@ -26,6 +29,7 @@ export type VcsModuleConfig = {
   obliqueCollections?: ObliqueCollectionOptions[];
   categories?: { name: string; items: object[] }[];
   hiddenObjects?: HiddenObject[];
+  clippingPolygons?: ClippingPolygonObjectOptions[];
   flights?: FlightInstanceOptions[];
 };
 

package/src/vectorCluster/vectorClusterCesiumContext.ts

@@ -0,0 +1,123 @@
+import {
+  CustomDataSource,
+  EntityCollection,
+  Entity,
+  Scene,
+} from '@vcmap-cesium/engine';
+import { StyleLike } from 'ol/style/Style.js';
+import type { Feature } from 'ol/index.js';
+import {
+  CesiumVectorContext,
+  setReferenceForPicking,
+} from '../layer/cesium/vectorContext.js';
+import VectorProperties from '../layer/vectorProperties.js';
+import convert, { ConvertedItem } from '../util/featureconverter/convert.js';
+
+class VectorClusterCesiumContext implements CesiumVectorContext {
+  entities: EntityCollection;
+
+  private _featureItems = new Map<Feature, () => void>();
+
+  private _convertingFeatures: Map<Feature, () => void> = new Map();
+
+  constructor(dataSource: CustomDataSource) {
+    this.entities = dataSource.entities;
+  }
+
+  private _addConvertedItems(
+    feature: Feature,
+    allowPicking: boolean,
+    items: ConvertedItem[],
+  ): void {
+    let entityOptions: Entity.ConstructorOptions | undefined;
+    items.forEach((item) => {
+      if (item.type === 'billboard') {
+        entityOptions = entityOptions ?? {};
+        entityOptions.billboard = {
+          ...item.item,
+        };
+        entityOptions.position = entityOptions.position ?? item.item.position;
+      } else if (item.type === 'label') {
+        entityOptions = entityOptions ?? {};
+        entityOptions.label = item.item;
+        entityOptions.position = entityOptions.position ?? item.item.position;
+      }
+    });
+
+    if (entityOptions) {
+      const instance = this.entities.add(entityOptions);
+      if (instance) {
+        if (allowPicking) {
+          setReferenceForPicking(feature, instance);
+        }
+        this._featureItems.set(feature, (): void => {
+          this.entities.remove(instance);
+        });
+      }
+    }
+  }
+
+  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)?.();
+
+    if (deleted) {
+      convertedItems.forEach((item) => {
+        if (item.type === 'primitive') {
+          item.item.destroy();
+        }
+      });
+    } else {
+      this._addConvertedItems(
+        feature,
+        vectorProperties.getAllowPicking(feature),
+        convertedItems,
+      );
+    }
+  }
+
+  hasFeature(feature: Feature): boolean {
+    return (
+      this._featureItems.has(feature) || this._convertingFeatures.has(feature)
+    );
+  }
+
+  removeFeature(feature: Feature): void {
+    this._convertingFeatures.get(feature)?.();
+    this._convertingFeatures.delete(feature);
+    this._featureItems.get(feature)?.();
+    this._featureItems.delete(feature);
+  }
+
+  clear(): void {
+    this.entities.removeAll();
+    this._featureItems.clear();
+    this._convertingFeatures.forEach((destroy) => {
+      destroy();
+    });
+    this._convertingFeatures.clear();
+  }
+
+  destroy(): void {
+    this.clear();
+  }
+}
+
+export default VectorClusterCesiumContext;