@vcmap/core 5.0.0-rc.0

package/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 virtualcitySYSTEMS
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,44 @@
+# vcMap Core
+
+## Getting Started
+- clone Repo
+- npm install
+- npm run serve
+
+# Coding Conventions
+### Exporting from a module
+- You should export all variables, functions, class etc. from a module
+  which are required to use the API.
+- Make sure the names of exports have _meaning outside of their module_. E.g. a
+  function names `extend(destination: extent3D, source: extend3D):void` would need to be rephrased to `extend3DExtent`.
+- If you export things _just for testing your unit_ or other _internals only_ make
+  sure to set the `@private` doclet.
+  ```javascript
+  /**
+   * Resets the foo. Exported for testing
+   * @private
+   */
+  export function resetFooInstance() {} 
+  ```
+
+### TS & Typesafety
+- You should use the imported name in your doclets, e.g.:
+  ```javascript
+  import Vector from 'ol/source/Vector.js';
+  
+  /**
+   * @param {Vector} source
+   * @returns {Array<import("ol").Feature<import("ol/geom/Geometry").default>>}
+   */
+  function getAllFeatures(source) {
+    if (source instanceof Vector) {
+      return source.getFeatures();
+    }
+    return [];
+  }
+  ```
+- You should use dump file imports where possible (WebStorm cannot generate 
+  Intelisensse from default imports). Thus `@param {import("ol/Feature").default}`
+  would become: `@param {import("ol").Feature}`.
+- You will need to import library own classes use `@param {import("@vcmap/core").CesiumMap}`.
+- You do _not_ need to import `typedefs` since these are provided globally during type checking.

package/build/postinstall.js

@@ -0,0 +1,44 @@
+import path from 'path';
+import fs from 'fs';
+import { fileURLToPath } from 'url';
+
+/**
+ * This circumvents a bug in webstorm, where scoped module .d.ts files arent
+ * handled properly (there is no intellisense in webstorm otherwise)
+ * @returns {Promise<void>}
+ */
+async function fixCesiumTypes() {
+  const fileName = fileURLToPath(import.meta.url);
+  if (
+    path.resolve(path.dirname(fileName), '..') === process.cwd() &&
+    fs.existsSync(path.join(process.cwd(), 'build', 'types'))
+  ) {
+    console.log('Moving Cesium.d.ts');
+    await fs.promises.cp(
+      path.join(process.cwd(), 'node_modules', '@vcmap', 'cesium', 'Source', 'Cesium.d.ts'),
+      path.join(process.cwd(), 'build', 'types', 'Cesium_module.d.ts'),
+      { force: true },
+    );
+  }
+}
+
+/**
+ * There is a known, unfixed bug in tinyqueue. This is the fix (otherwise tinyqueue is not a constructor)
+ * @returns {Promise<void>}
+ */
+async function fixTinyQueue() {
+  const fileName = path.join(process.cwd(), 'node_modules', 'tinyqueue', 'package.json');
+  if (fs.existsSync(fileName)) {
+    const content = await fs.promises.readFile(fileName);
+    const jsonContent = JSON.parse(content);
+    jsonContent.browser = 'tinyqueue.min.js';
+    await fs.promises.writeFile(fileName, JSON.stringify(jsonContent, null, 2));
+  }
+}
+
+async function run() {
+  await Promise.all([fixTinyQueue(), fixCesiumTypes()]);
+  console.log('fixed modules');
+}
+
+await run();

package/index.js

@@ -0,0 +1,139 @@
+import './src/ol/geom/circle.js';
+import './src/ol/geom/geometryCollection.js';
+import './src/ol/feature.js';
+import './src/cesium/wallpaperMaterial.js';
+import './src/cesium/cesium3DTilePointFeature.js';
+import './src/cesium/cesium3DTileFeature.js';
+import './src/cesium/cesiumVcsCameraPrimitive.js';
+
+export { VcsClassRegistry, default as ClassRegistry } from './src/vcs/vcm/classRegistry.js';
+export { default as VcsEvent } from './src/vcs/vcm/event/vcsEvent.js';
+export { styleCollection, obliqueCollectionCollection } from './src/vcs/vcm/globalCollections.js';
+export { default as AbstractInteraction } from './src/vcs/vcm/interaction/abstractInteraction.js';
+export { default as CoordinateAtPixel } from './src/vcs/vcm/interaction/coordinateAtPixel.js';
+export { default as EventHandler } from './src/vcs/vcm/interaction/eventHandler.js';
+export { default as FeatureAtPixelInteraction } from './src/vcs/vcm/interaction/featureAtPixelInteraction.js';
+export { default as FeatureProviderInteraction } from './src/vcs/vcm/interaction/featureProviderInteraction.js';
+export { default as InteractionChain } from './src/vcs/vcm/interaction/interactionChain.js';
+export { BitCounter, ModificationKeyType, EventType, PointerKeyType, PointerEventType } from './src/vcs/vcm/interaction/interactionType.js';
+export { default as Buildings } from './src/vcs/vcm/layer/buildings.js';
+export { cesiumTilesetLastUpdated, getExtentFromTileset, default as CesiumTilesetCesium } from './src/vcs/vcm/layer/cesium/cesiumTilesetCesium.js';
+export { default as ClusterContext } from './src/vcs/vcm/layer/cesium/clusterContext.js';
+export { default as DataSourceCesium } from './src/vcs/vcm/layer/cesium/dataSourceCesium.js';
+export { default as OpenStreetMapCesium } from './src/vcs/vcm/layer/cesium/openStreetMapCesium.js';
+export { default as PointCloudCesium } from './src/vcs/vcm/layer/cesium/pointCloudCesium.js';
+export { default as RasterLayerCesium } from './src/vcs/vcm/layer/cesium/rasterLayerCesium.js';
+export { default as SingleImageCesium } from './src/vcs/vcm/layer/cesium/singleImageCesium.js';
+export { default as TerrainCesium } from './src/vcs/vcm/layer/cesium/terrainCesium.js';
+export { default as TMSCesium } from './src/vcs/vcm/layer/cesium/tmsCesium.js';
+export { default as VectorCesium } from './src/vcs/vcm/layer/cesium/vectorCesium.js';
+export { setReferenceForPicking, removeArrayFromCollection, removeFeatureFromMap, addPrimitiveToContext, default as VectorContext } from './src/vcs/vcm/layer/cesium/vectorContext.js';
+export { default as VectorRasterTileCesium } from './src/vcs/vcm/layer/cesium/vectorRasterTileCesium.js';
+export { toContext, getCanvasFromFeatures, default as VectorTileImageryProvider } from './src/vcs/vcm/layer/cesium/vectorTileImageryProvider.js';
+export { default as WMSCesium } from './src/vcs/vcm/layer/cesium/wmsCesium.js';
+export { default as WMTSCesium } from './src/vcs/vcm/layer/cesium/wmtsCesium.js';
+export { default as getJSONObjectFromObject } from './src/vcs/vcm/layer/cesium/x3dmHelper.js';
+export { default as CesiumTileset } from './src/vcs/vcm/layer/cesiumTileset.js';
+export { default as Czml } from './src/vcs/vcm/layer/czml.js';
+export { default as DataSource } from './src/vcs/vcm/layer/dataSource.js';
+export { default as FeatureLayer } from './src/vcs/vcm/layer/featureLayer.js';
+export { isTiledFeature, default as FeatureStore } from './src/vcs/vcm/layer/featureStore.js';
+export { default as FeatureStoreChanges } from './src/vcs/vcm/layer/featureStoreChanges.js';
+export { featureStoreStateSymbol, featureStoreState } from './src/vcs/vcm/layer/featureStoreState.js';
+export { originalStyle, highlighted, hidden, globalHidden, featureExists, FeatureVisibilityAction, synchronizeFeatureVisibility, default as FeatureVisibility } from './src/vcs/vcm/layer/featureVisibility.js';
+export { featureFromOptions, default as GeoJSON } from './src/vcs/vcm/layer/geojson.js';
+export { getEPSGCodeFromGeojson, updateLegacyFeature, parseGeoJSON, writeGeoJSONFeature, writeGeoJSON } from './src/vcs/vcm/layer/geojsonHelpers.js';
+export { getGlobalHider, getInstance, default as GlobalHider } from './src/vcs/vcm/layer/globalHider.js';
+export { vcsMetaVersion, default as Layer } from './src/vcs/vcm/layer/layer.js';
+export { default as LayerImplementation } from './src/vcs/vcm/layer/layerImplementation.js';
+export { default as LayerState } from './src/vcs/vcm/layer/layerState.js';
+export { vcsLayerName } from './src/vcs/vcm/layer/layerSymbols.js';
+export { default as LayerOblique } from './src/vcs/vcm/layer/oblique/layerOblique.js';
+export { getLongestSide, getResolutionOptions, getZoom, mercatorGeometryToImageGeometry, imageGeometryToMercatorGeometry, getPolygonizedGeometry, setNewGeometry } from './src/vcs/vcm/layer/oblique/obliqueHelpers.js';
+export { default as VectorOblique } from './src/vcs/vcm/layer/oblique/vectorOblique.js';
+export { default as OpenStreetMap } from './src/vcs/vcm/layer/openStreetMap.js';
+export { default as LayerOpenlayers } from './src/vcs/vcm/layer/openlayers/layerOpenlayers.js';
+export { default as OpenStreetMapOpenlayers } from './src/vcs/vcm/layer/openlayers/openStreetMapOpenlayers.js';
+export { default as RasterLayerOpenlayers } from './src/vcs/vcm/layer/openlayers/rasterLayerOpenlayers.js';
+export { default as SingleImageOpenlayers } from './src/vcs/vcm/layer/openlayers/singleImageOpenlayers.js';
+export { default as TileDebugOpenlayers } from './src/vcs/vcm/layer/openlayers/tileDebugOpenlayers.js';
+export { default as TMSOpenlayers } from './src/vcs/vcm/layer/openlayers/tmsOpenlayers.js';
+export { default as VectorOpenlayers } from './src/vcs/vcm/layer/openlayers/vectorOpenlayers.js';
+export { default as VectorTileOpenlayers } from './src/vcs/vcm/layer/openlayers/vectorTileOpenlayers.js';
+export { default as WMSOpenlayers } from './src/vcs/vcm/layer/openlayers/wmsOpenlayers.js';
+export { default as WMTSOpenlayers } from './src/vcs/vcm/layer/openlayers/wmtsOpenlayers.js';
+export { defaultPointCloudStyle, default as PointCloud } from './src/vcs/vcm/layer/pointCloud.js';
+export { TilingScheme, getTilingScheme, calculateMinLevel, default as RasterLayer } from './src/vcs/vcm/layer/rasterLayer.js';
+export { default as SingleImage } from './src/vcs/vcm/layer/singleImage.js';
+export { default as Terrain } from './src/vcs/vcm/layer/terrain.js';
+export { getTerrainProviderForUrl, sampleCesiumTerrainMostDetailed, sampleCesiumTerrain, getHeightFromTerrainProvider, isTerrainTileAvailable } from './src/vcs/vcm/layer/terrainHelpers.js';
+export { tiledLayerLoaded, globeLoaded } from './src/vcs/vcm/layer/tileLoadedHelper.js';
+export { default as MVTTileProvider } from './src/vcs/vcm/layer/tileProvider/mvtTileProvider.js';
+export { default as StaticGeojsonTileProvider } from './src/vcs/vcm/layer/tileProvider/staticGeojsonTileProvider.js';
+export { mercatorResolutionsToLevel, rectangleToExtent, default as TileProvider } from './src/vcs/vcm/layer/tileProvider/tileProvider.js';
+export { default as factory } from './src/vcs/vcm/layer/tileProvider/tileProviderFactory.js';
+export { getURL, default as URLTemplateTileProvider } from './src/vcs/vcm/layer/tileProvider/urlTemplateTileProvider.js';
+export { default as TMS } from './src/vcs/vcm/layer/tms.js';
+export { default as Vector } from './src/vcs/vcm/layer/vector.js';
+export { fvLastUpdated, globalHiderLastUpdated, updateFeatureVisibility, updateGlobalHider, synchronizeFeatureVisibilityWithSource, getGenericFeatureFromClickedObject } from './src/vcs/vcm/layer/vectorHelpers.js';
+export { AltitudeModeCesium, ClassificationTypeCesium, parseNearFarScalar, parseCartesian3, parseStoreyHeights, getAltitudeModeOptions, getClassificationTypeOptions, getNearFarValueOptions, getCartesian3Options, default as VectorProperties } from './src/vcs/vcm/layer/vectorProperties.js';
+export { alreadyTransformedToMercator, alreadyTransformedToImage, obliqueGeometry, doNotTransform, originalFeatureSymbol, actuallyIsCircle } from './src/vcs/vcm/layer/vectorSymbols.js';
+export { default as VectorTile } from './src/vcs/vcm/layer/vectorTile.js';
+export { default as WFS } from './src/vcs/vcm/layer/wfs.js';
+export { default as WMS } from './src/vcs/vcm/layer/wms.js';
+export { getWMSSource } from './src/vcs/vcm/layer/wmsHelpers.js';
+export { default as WMTS } from './src/vcs/vcm/layer/wmts.js';
+export { default as BaseOLMap } from './src/vcs/vcm/maps/baseOLMap.js';
+export { Mode, default as CameraLimiter } from './src/vcs/vcm/maps/cameraLimiter.js';
+export { default as CesiumMap } from './src/vcs/vcm/maps/cesium.js';
+export { default as VcsMap } from './src/vcs/vcm/maps/map.js';
+export { default as MapState } from './src/vcs/vcm/maps/mapState.js';
+export { getViewDirectionFromViewPoint, default as Oblique } from './src/vcs/vcm/maps/oblique.js';
+export { default as Openlayers } from './src/vcs/vcm/maps/openlayers.js';
+export { default as VcsObject } from './src/vcs/vcm/object.js';
+export { default as ObliqueCollection } from './src/vcs/vcm/oblique/ObliqueCollection.js';
+export { DataState, getStateFromStatesArray, default as ObliqueDataSet } from './src/vcs/vcm/oblique/ObliqueDataSet.js';
+export { default as ObliqueImage } from './src/vcs/vcm/oblique/ObliqueImage.js';
+export { default as ObliqueImageMeta } from './src/vcs/vcm/oblique/ObliqueImageMeta.js';
+export { default as ObliqueProvider } from './src/vcs/vcm/oblique/ObliqueProvider.js';
+export { default as ObliqueView } from './src/vcs/vcm/oblique/ObliqueView.js';
+export { ObliqueViewDirection, obliqueViewDirectionNames, getDirectionName } from './src/vcs/vcm/oblique/ObliqueViewDirection.js';
+export { sortRealWordEdgeCoordinates, checkLineIntersection, transformCWIFC, transformToImage, transformFromImage, hasSameOrigin, destroyCesiumEvent } from './src/vcs/vcm/oblique/helpers.js';
+export { getVersionFromImageJson, parseImageMeta, parseImageData, parseLegacyImageData } from './src/vcs/vcm/oblique/parseImageJson.js';
+export { default as ClippingObject } from './src/vcs/vcm/util/clipping/clippingObject.js';
+export { default as ClippingObjectManager } from './src/vcs/vcm/util/clipping/clippingObjectManager.js';
+export { createClippingPlaneCollection, copyClippingPlanesToCollection, clearClippingPlanes, setClippingPlanes, createClippingFeature, getClippingOptions } from './src/vcs/vcm/util/clipping/clippingPlaneHelper.js';
+export { default as Collection } from './src/vcs/vcm/util/collection.js';
+export { getShortLocaleDate, getShortLocaleTime, getISODateString, getDayOfYear, isLeapYear } from './src/vcs/vcm/util/dateTime.js';
+export { default as ExclusiveManager } from './src/vcs/vcm/util/exclusiveManager.js';
+export { default as Extent } from './src/vcs/vcm/util/extent.js';
+export { default as AbstractFeatureProvider } from './src/vcs/vcm/util/featureProvider/abstractFeatureProvider.js';
+export { getGenericFeatureFromProvidedFeature } from './src/vcs/vcm/util/featureProvider/featureProviderHelpers.js';
+export { isProvidedFeature, showProvidedFeature } from './src/vcs/vcm/util/featureProvider/featureProviderSymbols.js';
+export { default as TileProviderFeatureProvider } from './src/vcs/vcm/util/featureProvider/tileProviderFeatureProvider.js';
+export { getFormat, default as WMSFeatureProvider } from './src/vcs/vcm/util/featureProvider/wmsFeatureProvider.js';
+export { validateCircle, default as circleToCesium } from './src/vcs/vcm/util/featureconverter/circleToCesium.js';
+export { getStylesArray, default as convert } from './src/vcs/vcm/util/featureconverter/convert.js';
+export { createEmpty3D, createOrUpdate3D, extendXYZ, extendXY, extendZ, extendFlatCoordinates, createOrUpdateFromGeometry, createOrUpdateFromHeightInfo, make2D } from './src/vcs/vcm/util/featureconverter/extent3d.js';
+export { getMaterialAppearance, createClassificationPrimitive, createPrimitive, createOutlinePrimitive, createLinePrimitive, getMinHeightOrGroundLevel, getStoreyHeights, validateStoreys, getHeightAboveGround, getHeightInfo, getStoreyOptions, addPrimitivesToContext } from './src/vcs/vcm/util/featureconverter/featureconverterHelper.js';
+export { validateLineString, default as lineStringToCesium } from './src/vcs/vcm/util/featureconverter/lineStringToCesium.js';
+export { getBillboardOptions, getLabelOptions, getModelOptions, validatePoint, getCartesian3AndWGS84FromCoordinates, default as pointToCesium } from './src/vcs/vcm/util/featureconverter/pointToCesium.js';
+export { validatePolygon, default as polygonToCesium } from './src/vcs/vcm/util/featureconverter/polygonToCesium.js';
+export { getFlatCoordinatesFromSimpleGeometry, getFlatCoordinatesFromGeometry, circleFromCenterRadius, convertGeometryToPolygon, enforceEndingVertex, removeEndingVertex, removeEndingVertexFromGeometry, enforceRightHand } from './src/vcs/vcm/util/geometryHelpers.js';
+export { default as IndexedCollection } from './src/vcs/vcm/util/indexedCollection.js';
+export { isMobile } from './src/vcs/vcm/util/isMobile.js';
+export { default as LayerCollection } from './src/vcs/vcm/util/layerCollection.js';
+export { getLocaleChangedEvent, detectBrowserLocale, getCurrentLocale, setCurrentLocale } from './src/vcs/vcm/util/locale.js';
+export { default as MapCollection } from './src/vcs/vcm/util/mapCollection.js';
+export { coordinateAtDistance, initialBearingBetweenCoords, cartesian2DDistance, cartesian3DDistance } from './src/vcs/vcm/util/math.js';
+export { wgs84ToMercatorTransformer, mercatorToWgs84Transformer, setDefaultProjectionOptions, getDefaultProjection, wgs84Projection, mercatorProjection, default as Projection } from './src/vcs/vcm/util/projection.js';
+export { default as SplitScreen } from './src/vcs/vcm/util/splitScreen.js';
+export { defaultDeclarativeStyle, default as DeclarativeStyleItem } from './src/vcs/vcm/util/style/declarativeStyleItem.js';
+export { getShapeFromOptions, shapeCategory } from './src/vcs/vcm/util/style/shapesCategory.js';
+export { getStyleOrDefaultStyle } from './src/vcs/vcm/util/style/styleFactory.js';
+export { PatternType, hexToOlColor, cesiumColorToColor, olColorToCesiumColor, parseColor, getCesiumColor, getStringColor, createPattern, olColorToHex, validateHexColor, parseFont, combineFont, colorInCanvas, getFillOptions, getStrokeOptions, getTextOptions, getTextFromOptions, getCssStyleFromTextStyle, emptyStyle, emptyColor, whiteColor, blackColor, getDefaultVectorStyleItemOptions, getDefaultCondition, defaultExtrudedHeightCondition } from './src/vcs/vcm/util/style/styleHelpers.js';
+export { StyleType, referenceableStyleSymbol, default as StyleItem } from './src/vcs/vcm/util/style/styleItem.js';
+export { olcsGeometryType, vectorStyleSymbol, defaultVectorStyle, fromCesiumColor, default as VectorStyleItem } from './src/vcs/vcm/util/style/vectorStyleItem.js';
+export { embedIconsInStyle, default as writeStyle } from './src/vcs/vcm/util/style/writeStyle.js';
+export { isSameOrigin } from './src/vcs/vcm/util/urlHelpers.js';
+export { propertyEqualsEpsilon, angleEqualsEpsilon, coordinateEqualsEpsilon, default as ViewPoint } from './src/vcs/vcm/util/viewpoint.js';

package/package.json

@@ -0,0 +1,92 @@
+{
+  "name": "@vcmap/core",
+  "version": "5.0.0-rc.0",
+  "description": "",
+  "main": "index.js",
+  "type": "module",
+  "types": "index.d.ts",
+  "scripts": {
+    "test": "node --experimental-json-modules node_modules/mocha/bin/_mocha --exit --require tests/setupJsdom.js --require tests/setup.js --file tests/vcs.js --recursive \"tests/**/*spec.js\"",
+    "lint": "eslint .",
+    "pretype-check": "npm run build-typedefs",
+    "type-check": "node build/typeCheck.js",
+    "postinstall": "node build/postinstall.js",
+    "coverage": "c8 --reporter text-summary npm run test",
+    "coverage:gitlab": "c8 --reporter text-summary npm run test -- --reporter mocha-junit-reporter",
+    "serve": "npx wds --node-resolve --open --watch",
+    "build-index": "jsdoc -c build/index/conf.json",
+    "build-typedefs": "jsdoc -c build/info/conf.json",
+    "build-tsd": "node build/buildDTs.js",
+    "prepare": "npm run build-index && npm run build-tsd"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/virtualcitySYSTEMS/map-core.git"
+  },
+  "files": [
+    "build/postinstall.js",
+    "src/",
+    "LICENSE.md",
+    "README.md",
+    "index.js"
+  ],
+  "author": "Virtual City Systems",
+  "license": "MIT",
+  "devDependencies": {
+    "@rollup/plugin-commonjs": "^18.0.0",
+    "@rollup/plugin-node-resolve": "^11.2.1",
+    "@vcmap/cesium": "^1.87.3",
+    "@vcsuite/eslint-config": "^2.0.3",
+    "@vcsuite/tsd-jsdoc": "^1.0.2",
+    "@web/dev-server": "^0.1.11",
+    "@web/dev-server-rollup": "^0.3.3",
+    "c8": "^7.7.1",
+    "canvas": "^2.8.0",
+    "chai": "^4.3.4",
+    "eslint": "^8.1.0",
+    "jsdoc": "^3.6.7",
+    "jsdoc-plugin-typescript": "^2.0.6",
+    "jsdom": "^16.5.2",
+    "jsdom-global": "^3.0.2",
+    "mocha": "^9.1.3",
+    "mocha-junit-reporter": "^2.0.2",
+    "ol": "^6.9.0",
+    "sinon": "^9.2.4",
+    "sinon-chai": "^3.6.0",
+    "typescript": "^4.4.4"
+  },
+  "peerDependencies": {
+    "@vcmap/cesium": "~1.87.2",
+    "ol": "^6.5.0"
+  },
+  "eslintConfig": {
+    "extends": [
+      "@vcsuite/eslint-config/vue"
+    ],
+    "rules": {
+      "import/extensions": [
+        "error",
+        "always"
+      ]
+    }
+  },
+  "eslintIgnore": [
+    "node_modules",
+    "coverage",
+    "index.js",
+    "*.d.ts"
+  ],
+  "dependencies": {
+    "@types/rbush": "^3.0.0",
+    "@vcsuite/check": "^1.0.3",
+    "@vcsuite/logger": "^1.0.1",
+    "@vcsuite/parsers": "^1.0.1",
+    "axios": "^0.21.4",
+    "fast-deep-equal": "^3.1.3",
+    "proj4": "^2.7.2",
+    "rbush": ">=3.0.1",
+    "rbush-knn": "^3.0.1",
+    "underscore.template": "^0.1.7",
+    "uuid": "^8.3.2"
+  }
+}

package/src/cesium/cesium3DTileFeature.js

@@ -0,0 +1,9 @@
+// @ts-nocheck
+import { Cesium3DTileFeature } from '@vcmap/cesium';
+
+/**
+ * @returns {string|number}
+ */
+Cesium3DTileFeature.prototype.getId = function getId() {
+  return this.getProperty('id') || `${this.content.url}${this._batchId}`;
+};

package/src/cesium/cesium3DTilePointFeature.js

@@ -0,0 +1,9 @@
+// @ts-nocheck
+import { Cesium3DTilePointFeature } from '@vcmap/cesium';
+
+/**
+ * @returns {string|number}
+ */
+Cesium3DTilePointFeature.prototype.getId = function getId() {
+  return this.getProperty('id') || `${this.content.url}${this._batchId}`;
+};

package/src/cesium/cesiumVcsCameraPrimitive.js

@@ -0,0 +1,146 @@
+// @ts-nocheck
+import {
+  Cartesian3,
+  Matrix3,
+  Quaternion,
+  Color,
+  Primitive,
+  GeometryInstance,
+  FrustumGeometry,
+  ColorGeometryInstanceAttribute,
+  PerInstanceColorAppearance,
+  FrustumOutlineGeometry,
+  destroyObject,
+} from '@vcmap/cesium';
+
+const scratchRight = new Cartesian3();
+const scratchRotation = new Matrix3();
+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
+ */
+class VcsCameraPrimitive {
+  /**
+   * @param {VcsCameraPrimitiveOptions} options
+   */
+  constructor(options) {
+    this._outlinePrimitives = [];
+    this._planesPrimitives = [];
+    /** @type {boolean} */
+    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.id = options.id || {};
+  }
+
+  update(frameState) {
+    if (!this.show) {
+      return;
+    }
+
+    const planesPrimitives = this._planesPrimitives;
+    const outlinePrimitives = this._outlinePrimitives;
+    let i;
+    if (planesPrimitives.length === 0) {
+      const camera = this._camera;
+      const cameraFrustum = camera.frustum;
+      const frustum = cameraFrustum.clone();
+      const frustumSplits = scratchSplits; // Use near and far planes if no splits created
+      frustumSplits[0] = this._camera.frustum.near;
+      frustumSplits[1] = this._camera.frustum.far;
+
+      const position = camera.positionWC;
+      const direction = camera.directionWC;
+      const up = camera.upWC;
+      let right = camera.rightWC;
+      right = Cartesian3.negate(right, scratchRight);
+
+      const rotation = scratchRotation;
+      Matrix3.setColumn(rotation, 0, right, rotation);
+      Matrix3.setColumn(rotation, 1, up, rotation);
+      Matrix3.setColumn(rotation, 2, direction, rotation);
+
+      const orientation = Quaternion.fromRotationMatrix(rotation, scratchOrientation);
+
+      planesPrimitives.length = 1;
+      outlinePrimitives.length = 1;
+
+      frustum.near = frustumSplits[0];
+      frustum.far = frustumSplits[1];
+
+      planesPrimitives[0] = new Primitive({
+        allowPicking: this.allowPicking,
+        geometryInstances: new GeometryInstance({
+          geometry: new FrustumGeometry({
+            origin: position,
+            orientation,
+            frustum,
+            _drawNearPlane: true,
+          }),
+          attributes: {
+            color: ColorGeometryInstanceAttribute.fromColor(Color.fromAlpha(this._color, 0.1, scratchColor)),
+          },
+          id: this.id,
+          pickPrimitive: this,
+        }),
+        appearance: new PerInstanceColorAppearance({
+          translucent: true,
+          flat: true,
+        }),
+        asynchronous: false,
+      });
+
+      outlinePrimitives[0] = new Primitive({
+        allowPicking: this.allowPicking,
+        geometryInstances: new GeometryInstance({
+          geometry: new FrustumOutlineGeometry({
+            origin: position,
+            orientation,
+            frustum,
+            _drawNearPlane: true,
+          }),
+          attributes: {
+            color: ColorGeometryInstanceAttribute.fromColor(this._color),
+          },
+          id: this.id,
+          pickPrimitive: this,
+        }),
+        appearance: new PerInstanceColorAppearance({
+          translucent: false,
+          flat: true,
+        }),
+        asynchronous: false,
+      });
+    }
+    const { length } = planesPrimitives;
+    for (i = 0; i < length; ++i) {
+      outlinePrimitives[i].update(frameState);
+      planesPrimitives[i].update(frameState);
+    }
+  }
+
+  destroy() {
+    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();
+    }
+    return destroyObject(this);
+  }
+}
+
+export default VcsCameraPrimitive;

package/src/cesium/wallpaperMaterial.js

@@ -0,0 +1,64 @@
+// @ts-nocheck
+import { Material, Cartesian2 } from '@vcmap/cesium';
+
+/**
+ * @file Wallpaper Material to implement openlayers pattern support in cesium
+ */
+
+// Call this once at application startup
+// eslint-disable-next-line no-underscore-dangle
+Material._materialCache.addMaterial('Wallpaper', {
+  fabric: {
+    type: 'Wallpaper',
+    uniforms: {
+      image: Material.DefaultImageId,
+      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',
+    },
+  },
+  translucent: false,
+});
+
+// //Create an instance and assign to anything that has a material property.
+// //scene - the scene
+// //image - the image (I think both a url or Image object are supported)
+// //anchor - A Cartesian3 that is the most southern and westard point of the geometry
+// var WallPaperMaterialProperty = function(scene, image, anchor) {
+//   this._scene = scene;
+//   this._image = image;
+//   this._anchor = anchor;
+//   this.definitionChanged = new Cesium.Event();
+//   this.isConstant = true;
+// };
+//
+// WallPaperMaterialProperty.prototype.getType = function(time) {
+//   return 'Wallpaper';
+// };
+//
+// WallPaperMaterialProperty.prototype.getValue = function(time, result) {
+//   if (!Cesium.defined(result)) {
+//     result = {
+//       image : undefined,
+//       anchor : undefined
+//     };
+//   }
+//
+//   result.image = this._image;
+//   result.anchor = Cesium.SceneTransforms.wgs84ToDrawingBufferCoordinates(this._scene, this._anchor, result.anchor);
+//   if(Cesium.defined(result.anchor)){
+//     result.anchor.x = Math.floor(result.anchor.x);
+//     result.anchor.y = Math.floor(result.anchor.y);
+//   } else {
+//     result.anchor = new Cesium.Cartesian2(0, 0);
+//   }
+//   return result;
+// };
+//
+// WallPaperMaterialProperty.prototype.equals = function(other) {
+//   return this === other || //
+//     (other instanceof  WallPaperMaterialProperty && //
+//       this._image === other._image);
+// };

package/src/ol/feature.js

@@ -0,0 +1,47 @@
+import Feature from 'ol/Feature.js';
+
+/**
+ * To be used for cesium 3D style functions
+ * @param {string} property
+ * @returns {*}
+ */
+Feature.prototype.getProperty = function getProperty(property) {
+  if (property === 'attributes') {
+    const properties = this.getProperties();
+    if (this.getGeometryName()) {
+      delete properties[this.getGeometryName()];
+    }
+    return properties;
+  } else if (property === 'olcs_geometryType') {
+    const type = this.getGeometry().getType();
+    if (type === 'Polygon') {
+      return 1;
+    } else if (type === 'LineString') {
+      return 2;
+    } else if (type === 'Point') {
+      return 3;
+    } else if (type === 'Circle') {
+      return 1;
+    } else if (type === 'MultiPolygon') {
+      return 1;
+    } else if (type === 'MultiLineString') {
+      return 2;
+    } else if (type === 'MultiPoint') {
+      return 3;
+    }
+    return undefined;
+  }
+  return this.get(property);
+};
+
+/**
+ * To be used for cesium 3D style functions
+ * @param {string} property
+ * @returns {*}
+ */
+Feature.prototype.getPropertyInherited = function getPropertyInherited(property) {
+  return this.getProperty(property);
+};
+
+// TODO implement getExactClassName, isClass & isExactClass
+// TODO implement feature.content.tileset.timeSinceLoad

package/src/ol/geom/circle.js

@@ -0,0 +1,24 @@
+import Circle from 'ol/geom/Circle.js';
+import { check } from '@vcsuite/check';
+import { cartesian2DDistance, cartesian3DDistance } from '../../vcs/vcm/util/math.js';
+
+/**
+ * @returns {Array<import("ol/coordinate").Coordinate>} returns an Array where the first coordinate is the center, and the second the center with an x offset of radius
+ */
+// @ts-ignore
+Circle.prototype.getCoordinates = function getCoordinates() {
+  return [this.getCenter(), this.getLastCoordinate()];
+};
+
+/**
+ * @param {Array<import("ol/coordinate").Coordinate>} coordinates - array of length two. The first coordinate is treated as the center, the second as the center with an x offset of radius
+ * @param {import("ol/geom/GeometryLayout").default=} optLayout
+ */
+Circle.prototype.setCoordinates = function setCoordinates(coordinates, optLayout) {
+  check(coordinates, [[Number]]);
+  check(coordinates.length, 2);
+
+  const layout = optLayout || this.getLayout();
+  const getRadius = /XYM?/.test(layout) ? cartesian2DDistance : cartesian3DDistance;
+  this.setCenterAndRadius(coordinates[0], getRadius(coordinates[0], coordinates[1]), optLayout);
+};