@vcmap/core 5.0.0-rc.10 → 5.0.0-rc.13

package/tests/data/terrain/layer.json

@@ -0,0 +1,136 @@
+{
+    "tilejson": "2.1.0",
+    "qmc-version": "3.5-0-g0f89f13_64bit_QMC_virtualcitySYSTEMS_GmbH",
+    "version": "1.1536156513599457",
+    "format": "quantized-mesh-1.0",
+    "scheme": "tms",
+    "extensions": [
+        "octvertexnormals"
+    ],
+    "tiles": [
+        "{z}/{x}/{y}.terrain?v={version}"
+    ],
+    "minzoom": 0,
+    "maxzoom": 13,
+    "bounds": [
+        -180.0,
+        -90.0,
+        180.0,
+        90.0
+    ],
+    "projection": "EPSG:4326",
+    "available": [
+      [
+        {
+          "endY": 0,
+          "endX": 1,
+          "startX": 0,
+          "startY": 0
+        }
+      ],
+      [
+        {
+          "endY": 1,
+          "endX": 2,
+          "startX": 2,
+          "startY": 1
+        }
+      ],
+      [
+        {
+          "endY": 3,
+          "endX": 4,
+          "startX": 4,
+          "startY": 3
+        }
+      ],
+      [
+        {
+          "endY": 6,
+          "endX": 8,
+          "startX": 8,
+          "startY": 6
+        }
+      ],
+      [
+        {
+          "endY": 12,
+          "endX": 17,
+          "startX": 17,
+          "startY": 12
+        }
+      ],
+      [
+        {
+          "endY": 25,
+          "endX": 34,
+          "startX": 34,
+          "startY": 25
+        }
+      ],
+      [
+        {
+          "endY": 50,
+          "endX": 68,
+          "startX": 68,
+          "startY": 50
+        }
+      ],
+      [
+        {
+          "endY": 101,
+          "endX": 137,
+          "startX": 137,
+          "startY": 101
+        }
+      ],
+      [
+        {
+          "endY": 202,
+          "endX": 275,
+          "startX": 275,
+          "startY": 202
+        }
+      ],
+      [
+        {
+          "endY": 405,
+          "endX": 550,
+          "startX": 550,
+          "startY": 405
+        }
+      ],
+      [
+        {
+          "endY": 810,
+          "endX": 1100,
+          "startX": 1100,
+          "startY": 810
+        }
+      ],
+      [
+        {
+          "endY": 1621,
+          "endX": 2200,
+          "startX": 2200,
+          "startY": 1621
+        }
+      ],
+      [
+        {
+          "endY": 3243,
+          "endX": 4400,
+          "startX": 4400,
+          "startY": 3242
+        }
+      ],
+      [
+        {
+            "endY": 6486,
+            "endX": 8801,
+            "startX": 8800,
+            "startY": 6485
+        }
+      ]
+    ]
+}

package/tests/data/testGeoJSON.json

@@ -0,0 +1,161 @@
+{
+  "geometries": [
+    {
+      "type": "Point",
+      "coordinates": [
+        1,
+        1,
+        1
+      ]
+    },
+    {
+      "type": "MultiPoint",
+      "coordinates": [
+        [
+          1,
+          1,
+          1
+        ],
+        [
+          2,
+          2,
+          2
+        ]
+      ]
+    },
+    {
+      "type": "LineString",
+      "coordinates": [
+        [1, 1, 1],
+        [2, 2, 2]
+      ]
+    },
+    {
+      "type": "MultiLineString",
+      "coordinates": [
+        [
+          [1, 1, 1],
+          [2, 2, 2]
+        ],
+        [
+          [3, 3, 3],
+          [4, 4, 4]
+        ]
+      ]
+    },
+    {
+      "type": "Polygon",
+      "coordinates": [
+        [
+          [0, 0, 0],
+          [10, 0, 0],
+          [10, 10, 0],
+          [0, 10, 0],
+          [0, 0, 0]
+        ],
+        [
+          [2, 2, 0],
+          [2, 8, 0],
+          [8, 8, 0],
+          [8, 2, 0],
+          [2, 2, 0]
+        ]
+      ]
+    },
+    {
+      "type": "MultiPolygon",
+      "coordinates": [
+        [
+          [
+            [0, 0, 0],
+            [1, 1, 0],
+            [0, 1, 0],
+            [0, 0, 0]
+          ]
+        ],
+        [
+          [
+            [2, 2, 0],
+            [4, 2, 0],
+            [4, 4, 0],
+            [2, 2, 0]
+          ]
+        ]
+      ]
+    }
+  ],
+  "feature": {
+    "type": "Feature",
+    "id": "test",
+    "properties": {
+      "foo": 1,
+      "bar": "test"
+    },
+    "geometry": {
+      "type": "Point",
+      "coordinates": [1, 1, 1]
+    }
+  },
+  "circle": {
+    "type": "Feature",
+    "radius": 10,
+    "properties": {
+      "foo": 1,
+      "bar": "test"
+    },
+    "geometry": {
+      "type": "Point",
+      "coordinates": [1, 1, 1]
+    }
+  },
+  "featureCollection": {
+    "type": "FeatureCollection",
+    "features": [
+      {
+        "type": "Feature",
+        "properties": {
+          "name": "foo"
+        },
+        "geometry": {
+          "type": "Point",
+          "coordinates": [1, 1, 1]
+        }
+      },
+      {
+        "type": "Feature",
+        "radius": 10,
+        "properties": {
+          "name": "bar"
+        },
+        "geometry": {
+          "type": "Point",
+          "coordinates": [1, 1, 1]
+        }
+      }
+    ]
+  },
+  "featureWithStyle": {
+    "id": "test",
+    "geometry": {
+      "type": "Point",
+      "coordinates": [1, 1, 1]
+    },
+    "vcsMeta":{
+      "style": {
+        "fill": {
+          "color": [255, 0, 0, 1]
+        },
+        "stroke": {
+          "color": [255, 0, 0, 1],
+          "width": 2
+        },
+        "image": {
+          "src": "test"
+        },
+        "text": {
+          "fill": { "color": [255, 0, 0, 1] }
+        }
+      }
+    }
+  }
+}

package/tests/unit/helpers/cesiumHelpers.js

@@ -0,0 +1,272 @@
+import {
+  BoundingSphere,
+  Entity,
+  Camera,
+  WebMercatorProjection,
+  PrimitiveCollection,
+  Globe,
+  Event as CesiumEvent,
+  SceneMode,
+  ImageryLayerCollection,
+  Clock,
+  DataSourceCollection,
+  ScreenSpaceEventHandler,
+  Color,
+  Cesium3DTileFeature,
+} from '@vcmap/cesium';
+import TweenCollection from '@vcmap/cesium/Source/Scene/TweenCollection.js';
+import ContextLimits from '@vcmap/cesium/Source/Renderer/ContextLimits.js';
+
+import CesiumTilesetLayer from '../../../src/layer/cesiumTilesetLayer.js';
+import DataSourceLayer from '../../../src/layer/dataSourceLayer.js';
+import CesiumMap from '../../../src/map/cesiumMap.js';
+import importJSON from './importJSON.js';
+
+const defaultTileset = await importJSON('./tests/data/buildings/tileset.json');
+defaultTileset.root.children = [];
+defaultTileset.properties = {};
+
+export const tilesetJSON = defaultTileset;
+
+/**
+ * @param {Sinon.SinonSandbox} sandbox
+ * @param {string=} url
+ * @returns {*|Sinon.SinonFakeServer|null}
+ */
+export function createTilesetServer(sandbox, url) {
+  const server = sandbox ? sandbox.useFakeServer() : sinon.createFakeServer();
+  server.autoRespond = true;
+  server.respondImmediately = true;
+  server.respondWith(
+    url || 'http://test.com/tileset.json',
+    [200, { 'Content-Type': 'application/json' }, JSON.stringify(tilesetJSON)],
+  );
+  server.respond();
+  return server;
+}
+
+/**
+ * @param {Sinon.SinonSandbox} sandbox
+ * @param {CesiumMap=} cesiumMap
+ * @param {string=} name
+ * @returns {Promise<CesiumTilesetLayer>}
+ */
+export async function createInitializedTilesetLayer(sandbox, cesiumMap, name) {
+  createTilesetServer(sandbox);
+  const tilesetLayer = new CesiumTilesetLayer({
+    url: 'http://test.com/tileset.json',
+    name,
+  });
+
+  await tilesetLayer.initialize();
+  if (cesiumMap) {
+    cesiumMap.layerCollection.add(tilesetLayer);
+    const impls = tilesetLayer.getImplementationsForMap(cesiumMap);
+    await Promise.all(impls.map(async (impl) => {
+      await impl.initialize();
+      Object.defineProperty(impl.cesium3DTileset, 'boundingSphere', {
+        get() {
+          return new BoundingSphere();
+        },
+      });
+    }));
+  }
+
+  return tilesetLayer;
+}
+
+export function createEntities(numberOfEntities = 1) {
+  const layer = new DataSourceLayer({});
+
+  const entities = new Array(numberOfEntities);
+  for (let i = 0; i < numberOfEntities; i++) {
+    entities[i] = new Entity({
+      model: {},
+    });
+    layer.addEntity(entities[i]);
+  }
+
+  return {
+    layer,
+    entities,
+  };
+}
+
+/**
+ * @param {sinon.sandbox} sandbox
+ * @param {Cesium/Event} event
+ * @returns {sinon.spy}
+ */
+export function getCesiumEventSpy(sandbox, event) {
+  const spy = sandbox.spy();
+  const listener = event.addEventListener(function callback() {
+    listener();
+    // eslint-disable-next-line prefer-rest-params
+    spy(...arguments);
+  });
+  return spy;
+}
+
+export function getMockScene() {
+  const scene = {
+    screenSpaceCameraController: {
+      enableInputs: true,
+    },
+    globe: new Globe(),
+    mode: SceneMode.SCENE3D,
+    tweens: new TweenCollection(),
+    primitives: new PrimitiveCollection(),
+    groundPrimitives: new PrimitiveCollection(),
+    imageryLayers: new ImageryLayerCollection(),
+    drawingBufferHeight: 100,
+    drawingBufferWidth: 100,
+    postRender: new CesiumEvent(),
+    preUpdate: new CesiumEvent(),
+    mapProjection: new WebMercatorProjection(),
+    shadowMap: { enabled: false },
+    canvas: document.createElement('canvas'),
+    terrainProvider: {
+      readyPromise: Promise.resolve(),
+    },
+    frameState: {
+      mode: undefined,
+      context: {
+        depthTexture: true,
+        stencilBuffer: true,
+      },
+      lineWidth: 1,
+    },
+    context: {
+      depthTexture: true,
+      stencilBuffer: true,
+    },
+    render() {},
+    pick() {},
+    pickPosition() {},
+    destroy() {
+      this.primitives.destroy();
+      this.groundPrimitives.destroy();
+      this.imageryLayers.destroy();
+      this.globe.destroy();
+      this.canvas = null;
+    },
+  };
+  const camera = new Camera(scene);
+  const originalFlyTo = camera.flyTo;
+
+  camera.flyTo = function flyTo(options) {
+    options.duration = 0;
+    originalFlyTo.bind(camera)(options);
+  };
+
+  scene.camera = camera;
+  return scene;
+}
+
+export function getCesiumMap(mapOptions) {
+  const map = new CesiumMap(mapOptions || {});
+  const scene = getMockScene();
+  map._cesiumWidget = {
+    scene,
+    camera: scene.camera,
+    render: scene.render,
+    resolutionScale: 1,
+    clock: new Clock({}),
+    destroy() {
+      this.scene.destroy();
+      this.scene = null;
+      this.camera = null;
+    },
+    resize() {},
+  };
+
+  map.screenSpaceEventHandler = new ScreenSpaceEventHandler(map._cesiumWidget.scene.canvas);
+  map.dataSourceDisplay = {
+    dataSources: new DataSourceCollection(),
+    isDestroyed() {
+      return false;
+    },
+    destroy() {
+      this.dataSources.destroy();
+    },
+  };
+  map.initialized = true;
+
+  return map;
+}
+
+/**
+ * @param {VcsApp} app
+ * @returns {Promise<CesiumMap>}
+ */
+export async function setCesiumMap(app) {
+  const map = getCesiumMap({ layerCollection: app.layers, target: app.maps.target });
+  app.maps.add(map);
+  await app.maps.setActiveMap(map.name);
+  return map;
+}
+
+/**
+ * creates usable default ContextLimits, copy pasted from chrome
+ */
+export function setupCesiumContextLimits() {
+  ContextLimits._highpFloatSupported = true;
+  ContextLimits._highpIntSupported = true;
+  ContextLimits._maximumAliasedLineWidth = 1;
+  ContextLimits._maximumAliasedPointSize = 1024;
+  ContextLimits._maximumColorAttachments = 8;
+  ContextLimits._maximumCombinedTextureImageUnits = 32;
+  ContextLimits._maximumCubeMapSize = 16384;
+  ContextLimits._maximumDrawBuffers = 8;
+  ContextLimits._maximumFragmentUniformVectors = 1024;
+  ContextLimits._maximumRenderbufferSize = 16384;
+  ContextLimits._maximumTextureFilterAnisotropy = 16;
+  ContextLimits._maximumTextureImageUnits = 16;
+  ContextLimits._maximumTextureSize = 16384;
+  ContextLimits._maximumVaryingVectors = 30;
+  ContextLimits._maximumVertexAttributes = 16;
+  ContextLimits._maximumVertexTextureImageUnits = 16;
+  ContextLimits._maximumVertexUniformVectors = 4095;
+  ContextLimits._maximumViewportHeight = 32767;
+  ContextLimits._maximumViewportWidth = 32767;
+  ContextLimits._minimumAliasedLineWidth = 1;
+  ContextLimits._minimumAliasedPointSize = 1;
+}
+
+class BatchTable {
+  constructor(properties) {
+    this.properties = properties;
+    this.color = new Color();
+    this.show = true;
+    this.destroyed = false;
+  }
+
+  getPropertyNames() { return Object.keys(this.properties); }
+
+  getProperty(id, prop) { return this.properties[prop]; }
+
+  getColor() { return this.color; }
+
+  setColor(id, color) { this.color = color; }
+
+  getShow() { return this.show; }
+
+  setShow(id, show) { this.show = show; }
+
+  isDestroyed() { return this.destroyed; }
+}
+
+/**
+ * @param {Object} properties
+ * @param {Object=} tileset
+ * @returns {Cesium.Cesium3DTileFeature}
+ */
+export function createDummyCesium3DTileFeature(properties = {}, tileset) {
+  const dummy = new Cesium3DTileFeature();
+  const content = { batchTable: new BatchTable(properties), isDestroyed() { return false; } };
+  if (tileset) {
+    content.tileset = tileset;
+  }
+  dummy._content = content;
+  return dummy;
+}

package/tests/unit/helpers/getFileNameFromUrl.js

@@ -0,0 +1,12 @@
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+/**
+ * @param {string} url
+ * @param {string} fileName
+ * @returns {string}
+ */
+export default function getFileNameFromUrl(url, fileName) {
+  const dirName = fileURLToPath(url);
+  return path.join(dirName, fileName);
+}

package/tests/unit/helpers/helpers.js

@@ -0,0 +1,11 @@
+/**
+ * helper function to wait for a timeout use: await timeout(1);
+ * @param {number} ms
+ * @returns {Promise<void>}
+ */
+// eslint-disable-next-line import/prefer-default-export
+export function timeout(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}

package/tests/unit/helpers/imageHelpers.js

@@ -0,0 +1,20 @@
+/**
+ * black Pixel dataURI
+ * @type {string}
+ */
+export const blackPixelURI = 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVQYV2NgYGD4DwABBAEAcCBlCwAAAABJRU5ErkJggg==';
+/**
+ * green Pixel dataURI
+ * @type {string}
+ */
+export const greenPixelURI = 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVQYV2Ng+M/wHwAEAQH/Xi7hpQAAAABJRU5ErkJggg==';
+/**
+ * red Pixel dataURI
+ * @type {string}
+ */
+export const redPixelURI = 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVQYV2P4z8DwHwAFAAH/plybXQAAAABJRU5ErkJggg==';
+/**
+ * blue Pixel dataURI
+ * @type {string}
+ */
+export const bluePixelURI = 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVQYV2NgYPj/HwADAgH/ybKt7gAAAABJRU5ErkJggg==';

package/tests/unit/helpers/importJSON.js

@@ -0,0 +1,15 @@
+import fs from 'fs';
+
+/**
+ * @param {string} fileName
+ * @returns {Promise<Object>}
+ */
+export default async function importJSON(fileName) {
+  if (fs.existsSync(fileName)) {
+    const content = await fs.promises.readFile(fileName);
+    return JSON.parse(content.toString());
+  }
+  // eslint-disable-next-line no-console
+  console.log(`${fileName} does not exist`);
+  return {};
+}

package/tests/unit/helpers/obliqueData.js

@@ -0,0 +1,76 @@
+/* eslint-disable camelcase */
+import nock from 'nock';
+import importJSON from './importJSON.js';
+
+const t2199_1342 = await importJSON('./tests/data/oblique/tiledImageData/12/2199/1342.json');
+const t2199_1343 = await importJSON('./tests/data/oblique/tiledImageData/12/2199/1343.json');
+const t2199_1344 = await importJSON('./tests/data/oblique/tiledImageData/12/2199/1344.json');
+const t2200_1342 = await importJSON('./tests/data/oblique/tiledImageData/12/2200/1342.json');
+const t2200_1343 = await importJSON('./tests/data/oblique/tiledImageData/12/2200/1343.json');
+const t2200_1344 = await importJSON('./tests/data/oblique/tiledImageData/12/2200/1344.json');
+const t2201_1342 = await importJSON('./tests/data/oblique/tiledImageData/12/2201/1342.json');
+const t2201_1343 = await importJSON('./tests/data/oblique/tiledImageData/12/2201/1343.json');
+const t2201_1344 = await importJSON('./tests/data/oblique/tiledImageData/12/2201/1344.json');
+const imageJsonTiled = await importJSON('./tests/data/oblique/tiledImageData/image.json');
+
+const tiledImageData = {
+  12: {
+    2199: {
+      1342: t2199_1342,
+      1343: t2199_1343,
+      1344: t2199_1344,
+    },
+    2200: {
+      1342: t2200_1342,
+      1343: t2200_1343,
+      1344: t2200_1344,
+    },
+    2201: {
+      1342: t2201_1342,
+      1343: t2201_1343,
+      1344: t2201_1344,
+    },
+  },
+};
+
+/**
+ * Center point of first image in 12/2200/1342
+ * @type {import("ol/coordinate").Coordinate}
+ */
+export const tiledMercatorCoordinate = [1487752.4290728183, 6888473.584735272, 0];
+/**
+ * Center point of first image in 12/2199/1342
+ * @type {import("ol/coordinate").Coordinate}
+ */
+export const tiledMercatorCoordinate2 = [1477722.079812214, 6897970.75026968, 0];
+/**
+ * Center point of first image
+ * @type {import("ol/coordinate").Coordinate}
+ */
+export const imagev35MercatorCoordinate = [1488644.796500772, 6892246.018669462, 0];
+
+/**
+ * serves http://localhost/tiledOblique/image.json
+ * @param {import("nock").Scope=} optScope
+ * @returns {import("nock").Scope} scope
+ */
+export default function getTiledObliqueImageServer(optScope) {
+  return (optScope || nock('http://localhost'))
+    .persist()
+    .get('/tiledOblique/image.json')
+    .reply(
+      200,
+      JSON.stringify(imageJsonTiled),
+      // zlib.gzipSync(Buffer.from(JSON.stringify(imageJsonTiled))),
+      { 'Content-Type': 'application/json' },
+    )
+    .get(/tiledOblique\/12\/(\d{4})\/(\d{4})\.json/)
+    .reply((uri) => {
+      const [x, y] = uri.match(/(\d{4})/g);
+      return [
+        200,
+        JSON.stringify(tiledImageData['12'][x][y]),
+        { 'Content-Type': 'application/json' },
+      ];
+    });
+}