@vcmap/core 5.0.0-rc.4 → 5.0.0-rc.5

package/index.d.ts

@@ -14,6 +14,103 @@ export class VcsCameraPrimitive {
     show: boolean;
 }
 
+export interface AppBackedCategoryOptions extends CategoryOptions {
+    collectionName: string;
+}
+
+export class AppBackedCategory extends Category<VcsObject> {
+    constructor(options: AppBackedCategoryOptions);
+    serializeForContext(contextId: string): null;
+}
+
+/**
+ */
+export interface CategoryOptions extends VcsObjectOptions {
+    title?: string | {
+        [key: string]: string;
+    };
+    typed?: boolean;
+    featureProperty?: string | undefined;
+    layerOptions?: VectorOptions;
+    /**
+     * items are not evaluated by the constructor but passed to parseItem during deserialization.
+    */
+    items?: object[];
+    keyProperty?: string;
+}
+
+/**
+ * A category contains user based items and is a special container. The container should not be created directly, but via
+ * the requestCategory API on the categories collection. Do not use toJSON to retrieve the state of a category, since
+ * categories outlive contexts and may be changed with mergeOptions to no longer reflect your initial state. Requestors
+ * should keep track of the requested options themselves.
+ */
+export class Category<T extends Object|VcsObject> extends VcsObject {
+    constructor(options: CategoryOptions);
+    static getDefaultConfig(): CategoryOptions;
+    title: string | {
+        [key: string]: string;
+    };
+    protected _app: VcsApp;
+    protected _layer: Vector;
+    /**
+     * The collection of this category.
+     */
+    readonly collection: OverrideCollection<T>;
+    /**
+     * Returns the layer of this collection. Caution, do not use the layer API to add or remove items.
+     * When adding items to the collection, the features are added to the layer async (timeout of 0), since there is weird behavior
+     * when removing and adding a feature with the same id in the same sync call.
+     */
+    layer: Vector | null;
+    protected _itemAdded(item: T): void;
+    protected _itemRemoved(item: T): void;
+    protected _itemReplaced(item: T): void;
+    protected _itemMoved(item: T): void;
+    /**
+     * Throws if typed, featureProperty and keyProperty do not match. Merges other options.
+     * Only merges: style, highlightStyle, zIndex & vectorProperties from layerOptions.
+     */
+    mergeOptions(options: CategoryOptions): void;
+    /**
+     * When setting the category, it MUST use the same unqiueKey as the previous collection (default is "name").
+     * All items in the current collection _will be destroyed_ and the current collection will be destroyed. The category will take
+     * complete ownership of the collection and destroy it once the category is destroyed. The collection will
+     * be turned into an {@see OverrideCollection}.
+     */
+    setCollection(collection: Collection<T>): void;
+    setApp(app: VcsApp): void;
+    protected _serializeItem(item: T): object[];
+    serializeForContext(contextId: string): CategoryOptions | null;
+    /**
+     * unique Name
+     */
+    readonly name: string;
+    properties: any;
+    readonly className: string;
+}
+
+export class CategoryCollection extends IndexedCollection<Category<Object|VcsObject>> {
+    constructor(app: VcsApp);
+    /**
+     * Do not call add directly. Use request category for adding categories.
+     */
+    add(category: Category<object | VcsObject>): number | null;
+    /**
+     * Categories should be static. Removing them can lead to undefined behavior.
+     */
+    remove(category: Category<object | VcsObject>): void;
+    /**
+     * Parses the category items. Items will only be parsed, if a category with said name exists. Otherwise,
+     * they will be cached, until such a category is requested.
+     */
+    parseCategoryItems(name: string, items: object[], contextId: string): Promise<void>;
+    /**
+     * Add categories with this API.
+     */
+    requestCategory(options: CategoryOptions): Promise<Category<object | VcsObject>>;
+}
+
 export class ClassRegistry {
     logger: import("@vcsuite/logger").Logger;
     /**
@@ -36,6 +133,26 @@ export class ClassRegistry {
 
 export const VcsClassRegistry: ClassRegistry;
 
+export interface VcsAppConfig {
+    id?: string | undefined;
+    layers?: LayerOptions[];
+    maps?: VcsMapOptions[];
+    styles?: StyleItemOptions[];
+    viewpoints?: ViewPointOptions[];
+    startingViewPointName?: string;
+    startingMapName?: string;
+    projection?: ProjectionOptions;
+    categories?: { name: string; items: object[]; }[];
+    obliqueCollections?: ObliqueCollectionOptions[];
+}
+
+export class Context {
+    constructor(config: VcsAppConfig);
+    readonly id: string;
+    readonly checkSum: string;
+    readonly config: VcsAppConfig;
+}
+
 export class VcsEvent<T extends any> {
     /**
      * The number of listeners
@@ -1567,6 +1684,13 @@ export interface FeatureStoreChangesValues {
     changed: boolean;
 }
 
+export interface CommitAction {
+    action: string;
+    feature: import("ol/format/GeoJSON").GeoJSONFeature;
+    original: import("ol").Feature<import("ol/geom/Geometry").default>;
+    success: (...params: any[]) => any;
+}
+
 /**
  * do not construct directly, use the layers .changeTracker instead
  */
@@ -6405,7 +6529,7 @@ export class WMSFeatureProvider extends AbstractFeatureProvider {
      * The feature response projection, if not present in the response format.
      */
     projection: Projection;
-    featureResponseCallback(response: import("axios").AxiosResponse<any>, coordinate: import("ol/coordinate").Coordinate): import("ol").Feature<import("ol/geom/Geometry").default>[];
+    featureResponseCallback(data: import("ol/format/GeoJSON").GeoJSONObject, coordinate: import("ol/coordinate").Coordinate): import("ol").Feature<import("ol/geom/Geometry").default>[];
     /**
      * The layer name of the associated layer
      */
@@ -6441,69 +6565,6 @@ export function validateCircle(circle: import("ol/geom/Circle").default): boolea
 
 export function getStylesArray(style: void | import("ol/style/Style").StyleLike, feature: import("ol").Feature<import("ol/geom/Geometry").default>, resolution?: number): import("ol/style/Style").default[];
 
-/**
- * Create an empty extent.
- * @returns Empty extent.
- */
-export function createEmpty3D(): number[];
-
-/**
- * Create a new extent or update the provided extent.
- * @param minX - Minimum X.
- * @param minY - Minimum Y.
- * @param minZ - Minimum Z.
- * @param maxX - Maximum X.
- * @param maxY - Maximum Y.
- * @param maxZ - Maximum Z.
- * @param [optExtent] - Destination extent.
- * @returns Extent.
- */
-export function createOrUpdate3D(minX: number, minY: number, minZ: number, maxX: number, maxY: number, maxZ: number, optExtent?: number[]): number[];
-
-/**
- * @param extent - Extent.
- * @param x - X.
- * @param y - Y.
- * @param z - Z.
- */
-export function extendXYZ(extent: number[], x: number, y: number, z: number): void;
-
-/**
- * @param extent - Extent.
- * @param x - X.
- * @param y - Y.
- */
-export function extendXY(extent: number[], x: number, y: number): void;
-
-/**
- * @param extent - Extent.
- * @param z - Z.
- */
-export function extendZ(extent: number[], z: number): void;
-
-/**
- * @param extent - Extent.
- * @param flatCoordinates - Flat coordinates.
- * @param stride - Stride.
- * @returns Extent.
- */
-export function extendFlatCoordinates(extent: number[], flatCoordinates: number[], stride: number): number[];
-
-/**
- * @param geometry - Geometry.
- * @param [optExtent] - Extent.
- * @returns Extent.
- */
-export function createOrUpdateFromGeometry(geometry: import("ol/geom/Geometry").default, optExtent?: number[]): number[];
-
-export function createOrUpdateFromHeightInfo(heightInfo: VectorHeightInfo, optExtent: number[]): void;
-
-/**
- * @param extent - Extent.
- * @returns Extent.
- */
-export function make2D(extent: number[]): import("ol/extent").Extent;
-
 export function getMaterialAppearance(scene: import("@vcmap/cesium").Scene, fill: import("ol/style/Fill").default, feature: import("ol").Feature<import("ol/geom/Geometry").default>): import("@vcmap/cesium").MaterialAppearance;
 
 export function createClassificationPrimitive(options: any, geometries: import("@vcmap/cesium").Geometry[], color: import("@vcmap/cesium").Color, classificationType: import("@vcmap/cesium").ClassificationType): import("@vcmap/cesium").ClassificationPrimitive;
@@ -6566,6 +6627,12 @@ export function getCartesian3AndWGS84FromCoordinates(coordinates: import("ol/coo
  */
 export function validatePolygon(polygon: import("ol/geom/Polygon").default): boolean;
 
+export function requestUrl(url: string, init?: RequestInit): Promise<Response>;
+
+export function requestJson(url: string, init?: RequestInit): Promise<any>;
+
+export function requestArrayBuffer(url: string, init?: RequestInit): Promise<ArrayBuffer>;
+
 export function getFlatCoordinatesFromSimpleGeometry(geometry: import("ol/geom/SimpleGeometry").default): import("ol/coordinate").Coordinate[];
 
 export function getFlatCoordinatesFromGeometry(geometry: import("ol/geom/Geometry").default, inputCoordinates?: any[]): import("ol/coordinate").Coordinate[];
@@ -6771,6 +6838,20 @@ export function cartesian2DDistance(point0: import("ol/coordinate").Coordinate,
 
 export function cartesian3DDistance(p1: import("ol/coordinate").Coordinate, p2: import("ol/coordinate").Coordinate): number;
 
+/**
+ * A symbol added to override collections.
+ */
+export const isOverrideCollection: symbol;
+
+/**
+ * @param getDynamicContextId - function to get the current dynamic context id
+ * @param [serializeItem] - optional function to serialize an item, defaults to returning item.toJSON or item: i => (i.toJSON || i)
+ * @param [deserializeItem] - optional desirialization function. defaults to returning the passed object: i => i
+ * @param [ctor] - optional constructor to validate deserialized items against. if passed, deserializeItem must be an instance of ctor.
+ * @param [determineShadowIndex] - return the index where a shadow should be inserted. only has relevance, if the collection is indexed. previous and current index may be null.
+ */
+export function makeOverrideCollection<T extends any>(collection: Collection<T>, getDynamicContextId: (...params: any[]) => any, serializeItem?: (...params: any[]) => any, deserializeItem?: (...params: any[]) => any, ctor?: any, determineShadowIndex?: ((...params: any[]) => any) | null): OverrideCollection<T>;
+
 /**
  */
 export interface ProjectionOptions {
@@ -6986,7 +7067,7 @@ export function getShapeFromOptions(options: VectorStyleItemImage): import("ol/s
 
 export const shapeCategory: any;
 
-export function getStyleOrDefaultStyle(styleOptions?: Reference | DeclarativeStyleItemOptions | VectorStyleItemOptions | StyleItem | string, defaultStyle?: VectorStyleItem | DeclarativeStyleItem): StyleItem;
+export function getStyleOrDefaultStyle(styleOptions?: Reference | DeclarativeStyleItemOptions | VectorStyleItemOptions | StyleItem | string, defaultStyle?: StyleItem): StyleItem;
 
 export interface FontObject {
     fontStyle: string;
@@ -7467,4 +7548,80 @@ export class ViewPoint extends VcsObject {
     readonly className: string;
 }
 
+export class VcsApp {
+    readonly id: string;
+    readonly maps: OverrideMapCollection;
+    readonly layers: OverrideLayerCollection;
+    readonly obliqueCollections: OverrideCollection<ObliqueCollection>;
+    readonly viewPoints: OverrideCollection<ViewPoint>;
+    readonly styles: OverrideCollection<StyleItem>;
+    readonly categories: CategoryCollection;
+    readonly destroyed: VcsEvent<void>;
+    readonly contextAdded: any;
+    readonly contextRemoved: any;
+    getContextById(id: string): Context;
+    protected _parseContext(context: Context): Promise<void>;
+    protected _setContextState(context: Context): Promise<void>;
+    addContext(context: Context): Promise<void>;
+    protected _removeContext(contextId: string): Promise<void>;
+    removeContext(contextId: string): Promise<void>;
+}
+
+export function getVcsAppById(id: string): VcsApp;
+
+export const contextIdSymbol: symbol;
+
+/**
+ * returns a constructor of a type.
+ */
+export function getObjectFromOptions(options: any, ...args: any[]): Promise<object | null>;
+
+export function deserializeMap(vcsApp: VcsApp, mapConfig: VcsMapOptions): Promise<VcsMap | null>;
+
+export function deserializeViewPoint(viewPointObject: ViewPointOptions): Promise<null | ViewPoint>;
+
+export function serializeLayer(vcsApp: VcsApp, layer: Layer): Promise<LayerOptions | null>;
+
+export function getLayerIndex(current: Layer, previous: Layer, currentIndex: number): number | null;
+
+export function destroyCollection(collection: Collection<any>): void;
+
+
+
+
+export interface OverrideCollectionInterface<T extends any> {
+    replaced: VcsEvent<T>;
+    shadowMap: Map<string, object[]>;
+    override: (item: T) => T;
+    parseItems: (items: object[], contextId: string) => Promise<void>;
+    removeContext: (contextId: string) => Promise<void>;
+    serializeContext: (contextId: string) => object[];
+}
+
+export class OverrideCollection<T extends any> extends Collection<T> implements OverrideCollectionInterface<T> {
+    replaced: VcsEvent<T>;
+    shadowMap: Map<string, object[]>;
+    override: (item: T) => T;
+    parseItems: (items: object[], contextId: string) => Promise<void>;
+    removeContext: (contextId: string) => Promise<void>;
+    serializeContext: (contextId: string) => object[];
+}
+
+export class OverrideLayerCollection extends LayerCollection implements OverrideCollectionInterface<Layer> {
+    replaced: VcsEvent<Layer>;
+    shadowMap: Map<string, object[]>;
+    override: (item: Layer) => Layer;
+    parseItems: (items: object[], contextId: string) => Promise<void>;
+    removeContext: (contextId: string) => Promise<void>;
+    serializeContext: (contextId: string) => object[];
+}
+
+export class OverrideMapCollection extends MapCollection implements OverrideCollectionInterface<VcsMap> {
+    replaced: VcsEvent<VcsMap>;
+    shadowMap: Map<string, object[]>;
+    override: (item: VcsMap) => VcsMap;
+    parseItems: (items: object[], contextId: string) => Promise<void>;
+    removeContext: (contextId: string) => Promise<void>;
+    serializeContext: (contextId: string) => object[];
+}
 

package/index.js

@@ -6,7 +6,11 @@ import './src/cesium/cesium3DTilePointFeature.js';
 import './src/cesium/cesium3DTileFeature.js';
 import './src/cesium/cesiumVcsCameraPrimitive.js';
 
+export { default as AppBackedCategory } from './src/vcs/vcm/category/appBackedCategory.js';
+export { default as Category } from './src/vcs/vcm/category/category.js';
+export { default as CategoryCollection } from './src/vcs/vcm/category/categoryCollection.js';
 export { VcsClassRegistry, default as ClassRegistry } from './src/vcs/vcm/classRegistry.js';
+export { default as Context } from './src/vcs/vcm/context.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';
@@ -114,11 +118,12 @@ export { default as TileProviderFeatureProvider } from './src/vcs/vcm/util/featu
 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 { default as Extent3D } 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 { requestUrl, requestJson, requestArrayBuffer } from './src/vcs/vcm/util/fetch.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';
@@ -126,6 +131,7 @@ export { default as LayerCollection } from './src/vcs/vcm/util/layerCollection.j
 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 { isOverrideCollection, default as makeOverrideCollection } from './src/vcs/vcm/util/overrideCollection.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';
@@ -137,3 +143,5 @@ export { olcsGeometryType, vectorStyleSymbol, defaultVectorStyle, fromCesiumColo
 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';
+export { getVcsAppById, default as VcsApp } from './src/vcs/vcm/vcsApp.js';
+export { contextIdSymbol, getObjectFromOptions, deserializeMap, deserializeViewPoint, serializeLayer, getLayerIndex, destroyCollection } from './src/vcs/vcm/vcsAppContextHelpers.js';

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@vcmap/core",
-  "version": "5.0.0-rc.4",
+  "version": "5.0.0-rc.5",
   "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\"",
+    "test": "node 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",
@@ -51,6 +51,8 @@
     "jsdom-global": "^3.0.2",
     "mocha": "^9.1.3",
     "mocha-junit-reporter": "^2.0.2",
+    "nock": "^13.2.4",
+    "node-fetch": "^3.2.0",
     "ol": "^6.9.0",
     "sinon": "^9.2.4",
     "sinon-chai": "^3.6.0",
@@ -63,13 +65,7 @@
   "eslintConfig": {
     "extends": [
       "@vcsuite/eslint-config/vue"
-    ],
-    "rules": {
-      "import/extensions": [
-        "error",
-        "always"
-      ]
-    }
+    ]
   },
   "eslintIgnore": [
     "node_modules",
@@ -82,7 +78,6 @@
     "@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",

package/src/vcs/vcm/category/appBackedCategory.js

@@ -0,0 +1,41 @@
+import Category from './category.js';
+import { VcsClassRegistry } from '../classRegistry.js';
+
+/**
+ * @typedef {CategoryOptions} AppBackedCategoryOptions
+ * @property {string} collectionName
+ */
+
+/**
+ * @class
+ * @extends {Category<import("@vcmap/core").VcsObject>}
+ */
+class AppBackedCategory extends Category {
+  static get className() { return 'category.AppBackedCategory'; }
+
+  /**
+   * @param {AppBackedCategoryOptions} options
+   */
+  constructor(options) {
+    options.typed = true;
+    super(options);
+    this._collectionName = options.collectionName;
+  }
+
+  setApp(app) {
+    super.setApp(app);
+    this.setCollection(this._app[this._collectionName]);
+  }
+
+  /**
+   * @param {string} contextId
+   * @returns {null}
+   */
+  // eslint-disable-next-line class-methods-use-this,no-unused-vars
+  serializeForContext(contextId) {
+    return null;
+  }
+}
+
+export default AppBackedCategory;
+VcsClassRegistry.registerClass(AppBackedCategory.className, AppBackedCategory);