@vcmap/core 5.0.0-rc.8 → 5.0.0-rc.9

package/index.d.ts

@@ -7,6 +7,7 @@ export interface AppBackedCategoryOptions extends CategoryOptions {
 
 export class AppBackedCategory extends Category<VcsObject> {
     constructor(options: AppBackedCategoryOptions);
+    protected _deserializeItem(config: VcsObjectOptions): Promise<VcsObject>;
     serializeForContext(contextId: string): null;
 }
 
@@ -16,7 +17,10 @@ export interface CategoryOptions extends VcsObjectOptions {
     title?: string | {
         [key: string]: string;
     };
-    typed?: boolean;
+    /**
+     * the class registry name on the current app to provide classes for this category. if provided, parseItems will deserialize using this class registry. See: {@link getObjectFromClassRegistry}.
+    */
+    classRegistryName?: string;
     featureProperty?: string | undefined;
     layerOptions?: VectorOptions;
     /**
@@ -40,6 +44,7 @@ export class Category<T extends Object|VcsObject> extends VcsObject {
     };
     protected _app: VcsApp;
     protected _layer: VectorLayer;
+    readonly classRegistryName: string;
     /**
      * The collection of this category.
      */
@@ -67,6 +72,10 @@ export class Category<T extends Object|VcsObject> extends VcsObject {
      */
     setCollection(collection: Collection<T>): void;
     setApp(app: VcsApp): void;
+    /**
+     * @returns // XXX should this still be async?
+     */
+    protected _deserializeItem(config: any): Promise<T>;
     protected _serializeItem(item: T): object[];
     serializeForContext(contextId: string): CategoryOptions | null;
     /**
@@ -111,26 +120,37 @@ export class VcsCameraPrimitive {
     show: boolean;
 }
 
-export class ClassRegistry {
-    logger: import("@vcsuite/logger").Logger;
+export class ClassRegistry<T extends Object|VcsObject> {
+    getClassNames(): string[];
     /**
      * Register a class by its class name.
      */
     registerClass(className: string, ctor: (...params: any[]) => any): void;
-    /**
-     * @param cb - a callback providing a promise which returns the constructor on resolve.
-     * used for lazy loading modules, e.g
-     * <code>ClassRegistry.registerDeferredClass(() => import('my-module').then(({ default: MyCtor }) => MyCtor));</code>
-     */
-    registerDeferredClass(className: string, cb: (...params: any[]) => any): void;
     /**
      * Gets the constructor for a registered class or undefined, if no such class was registerd
      */
-    getClass(className: string): ((...params: any[]) => any) | Promise<any> | undefined;
-    create(className: string, ...args: any[]): Promise<any>;
+    getClass(className: string): ((...params: any[]) => any) | undefined;
+    hasClass(className: string): boolean;
+    create(className: string, ...args: any[]): T;
+    createFromTypeOptions(options: any, ...args: any[]): T;
 }
 
-export const VcsClassRegistry: ClassRegistry;
+export const layerClassRegistry: ClassRegistry<Layer>;
+
+export const tileProviderClassRegistry: ClassRegistry<TileProvider>;
+
+export const featureProviderClassRegistry: ClassRegistry<AbstractFeatureProvider>;
+
+export const mapClassRegistry: ClassRegistry<VcsMap>;
+
+export const styleClassRegistry: ClassRegistry<StyleItem>;
+
+export const categoryClassRegistry: ClassRegistry<Category<any>>;
+
+/**
+ * Returns an object based on a class registry or override class registry and a typed options object. as opposed to ClassRegistry.createFromTypedOptions, this function never throws.
+ */
+export function getObjectFromClassRegistry<T extends Object|VcsObject>(classRegistry: OverrideClassRegistry<T> | ClassRegistry<T>, options: any, ...args: any[]): T | null;
 
 export interface VcsAppConfig {
     id?: string | undefined;
@@ -369,8 +389,6 @@ export class WMSFeatureProvider extends AbstractFeatureProvider {
     mapTypes: string[];
 }
 
-export const styleCollection: Collection<StyleItem>;
-
 /**
  */
 export interface ObliqueParameters {
@@ -1412,11 +1430,7 @@ export class DataSourceLayer extends Layer {
 /**
  */
 export interface FeatureLayerOptions extends LayerOptions {
-    style?: DeclarativeStyleItemOptions | VectorStyleItemOptions | StyleItem | string | undefined;
-    /**
-     * vcs:undocumented
-    */
-    activeStyleName?: string | undefined;
+    style?: DeclarativeStyleItemOptions | VectorStyleItemOptions | StyleItem | undefined;
     /**
      * properties to add to generic features, eg for display in the balloon
     */
@@ -1478,11 +1492,11 @@ export class FeatureLayer extends Layer {
      * Set properties, which are always added to the generic object, eg. for use in balloons
      */
     assignGenericFeatureProperties(properties: any): void;
-    getStyleOrDefaultStyle(styleOptions?: Reference | DeclarativeStyleItemOptions | VectorStyleItemOptions | StyleItem | string, defaultStyle?: VectorStyleItem | DeclarativeStyleItem): StyleItem;
+    getStyleOrDefaultStyle(styleOptions?: DeclarativeStyleItemOptions | VectorStyleItemOptions | StyleItem, defaultStyle?: VectorStyleItem | DeclarativeStyleItem): StyleItem;
     /**
      * Sets the style based on a styleName on a layer
      */
-    setStyle(style: string | import("ol/style/Style").default | import("ol/style/Style").StyleFunction | StyleItem, silent?: boolean): void;
+    setStyle(style: import("ol/style/Style").default | import("ol/style/Style").StyleFunction | StyleItem, silent?: boolean): void;
     /**
      * Clears the style of this layer
      */
@@ -2227,7 +2241,7 @@ export interface VcsMeta extends VectorPropertiesOptions {
      * the version of the vcsMeta schema
     */
     version?: string | undefined;
-    style?: VectorStyleItemOptions | DeclarativeStyleItemOptions | Reference | undefined;
+    style?: VectorStyleItemOptions | DeclarativeStyleItemOptions | undefined;
     embeddedIcons?: string[] | undefined;
     screenSpaceError?: number | undefined;
     flightOptions?: any | undefined;
@@ -3422,9 +3436,9 @@ export class MVTTileProvider extends TileProvider {
 
 /**
  */
-export interface StaticGeojsonTileProviderOptions extends TileProviderOptions {
+export interface StaticGeoJSONTileProviderOptions extends TileProviderOptions {
     /**
-     * geojson
+     * url to the geojson
     */
     url: string;
 }
@@ -3433,9 +3447,9 @@ export interface StaticGeojsonTileProviderOptions extends TileProviderOptions {
  * Loads the provided geojson url and tiles the content in memory, data is only requested once
  */
 export class StaticGeoJSONTileProvider extends TileProvider {
-    constructor(options: StaticGeojsonTileProviderOptions);
+    constructor(options: StaticGeoJSONTileProviderOptions);
     static readonly className: any;
-    static getDefaultOptions(): StaticGeojsonTileProviderOptions;
+    static getDefaultOptions(): StaticGeoJSONTileProviderOptions;
     url: string;
     /**
      * Cesium Webmercator TilingScheme
@@ -3634,8 +3648,6 @@ export class TileProvider extends VcsObject {
     readonly className: string;
 }
 
-export function factory(options: any): Promise<TileProvider>;
-
 /**
  */
 export interface URLTemplateTileProviderOptions extends TileProviderOptions {
@@ -4294,7 +4306,7 @@ export function synchronizeFeatureVisibility(source: FeatureVisibility, destinat
 /**
  */
 export interface VectorTileOptions extends FeatureLayerOptions {
-    tileProvider: TileProviderOptions;
+    tileProvider: TileProviderOptions | TileProvider;
     highlightStyle?: VectorStyleItemOptions | VectorStyleItem | undefined;
     vectorProperties?: VectorPropertiesOptions | undefined;
     /**
@@ -6118,6 +6130,53 @@ export function parseImageData(json: ObliqueImageJson, imageMetas: ObliqueImageM
 
 export function parseLegacyImageData(json: ObliqueImageJson, imageMetas: ObliqueImageMeta[]): ObliqueImage[];
 
+export class OverrideClassRegistry<T extends Object|VcsObject> {
+    constructor(coreClassRegistry: ClassRegistry<T>);
+    /**
+     * Called if a class was replaced. Is passed the className
+     */
+    replaced: VcsEvent<string>;
+    /**
+     * Called if a class was removed. Is passed the className
+     */
+    removed: VcsEvent<string>;
+    getClassNames(): string[];
+    /**
+     * Register a class for a given context by name. If the class already exists, it will be replaced and replaced called with the classeName.
+     */
+    registerClass(contextId: string, className: string, ctor: (...params: any[]) => any): void;
+    /**
+     * Unregister a previously registered class. You can only unregister classes added to this registry, not the underlying core registry.
+     * If when registering this class you have replaced class, it will be re-instated and replaced called.
+     * If there is no previously registered class, it will be removed and removed will be called.
+     */
+    unregisterClass(contextId: string, className: string): void;
+    /**
+     * Gets the constructor for a registered class or undefined, if no such class was registerd
+     */
+    getClass(className: string): ((...params: any[]) => any) | undefined;
+    hasClass(className: string): boolean;
+    /**
+     * Create an object of the given className. The constructor is passed args.
+     */
+    create(className: string, ...args: any[]): T;
+    /**
+     * A convenience API to pass in a serialized VcsObject directly. It calls create using options.type as the className.
+     * Will throw an error if options.type is not a string or options is not an Object.
+     * Passes options and args to the constructor in that order.
+     */
+    createFromTypeOptions(options: any, ...args: any[]): T;
+    /**
+     * Removes all classes registered from within a certain context. Will re-instate classes overwritten by the context
+     * and call the appropriate events, outlined in unregisterClass.
+     */
+    removeContext(contextId: string): void;
+    /**
+     * Destroys the override class registry
+     */
+    destroy(): void;
+}
+
 export interface DeclarativeStyleItemConditions {
     conditions: (string[] | string)[];
 }
@@ -6188,13 +6247,6 @@ export class DeclarativeStyleItem extends StyleItem {
     labelColor: any;
     font: any;
     pointSize: any;
-    title: string | {
-        [key: string]: string;
-    };
-    /**
-     * Legend entries
-     */
-    legend: StyleItemLegendEntry[];
     supportedLayers: string[];
     /**
      * Fired on style updates
@@ -6220,7 +6272,7 @@ export function getShapeFromOptions(options: VectorStyleItemImage): import("ol/s
 
 export const shapeCategory: any;
 
-export function getStyleOrDefaultStyle(styleOptions?: Reference | DeclarativeStyleItemOptions | VectorStyleItemOptions | StyleItem | string, defaultStyle?: StyleItem): StyleItem;
+export function getStyleOrDefaultStyle(styleOptions?: DeclarativeStyleItemOptions | VectorStyleItemOptions | StyleItem, defaultStyle?: StyleItem): StyleItem;
 
 export interface FontObject {
     fontStyle: string;
@@ -6325,64 +6377,21 @@ export interface StyleItemLegendEntry {
 /**
  */
 export interface StyleItemOptions extends VcsObjectOptions {
-    /**
-     * used in configuration to differentiate vector from declarative styles
-    */
-    type?: string | undefined;
-    /**
-     * name is used when none is specifies
-    */
-    title?: string | {
-        [key: string]: string;
-    } | undefined;
-    legend?: StyleItemLegendEntry[] | undefined;
     /**
      * colorBlendMode for 3D Tiledataset @see https://cesiumjs.org/import("@vcmap/cesium").Build/Documentation/Cesium3DTileColorBlendMode.html
     */
     colorBlendMode?: number;
 }
 
-/**
- */
-export interface Reference {
-    type?: string;
-    name: string;
-    /**
-     * vcs:undocumented this is not yet implemented
-    */
-    url?: string | undefined;
-}
-
 export interface StyleItemSections {
     meta?: boolean | undefined;
 }
 
-/**
- * Enumeration of possible style types.
- */
-export const enum StyleType {
-    VECTOR,
-    DECLARATIVE,
-    REFERENCE
-}
-
-/**
- * indicates, that this style is part of the config and can be referenced by name
- */
-export const referenceableStyleSymbol: symbol;
-
 /**
  * An abstract style definition which can be applied to a layer
  */
 export class StyleItem extends VcsObject {
     constructor(options: StyleItemOptions);
-    title: string | {
-        [key: string]: string;
-    };
-    /**
-     * Legend entries
-     */
-    legend: StyleItemLegendEntry[];
     supportedLayers: string[];
     /**
      * The 3D representation of this style
@@ -6397,19 +6406,14 @@ export class StyleItem extends VcsObject {
     style: any;
     isSupported(className: string): boolean;
     /**
-     * Gets the options for this style item to be used in a config or vcsMeta
-     */
-    getOptions(sections?: VectorStyleItemSections | DeclarativeStyleItemSections): VectorStyleItemOptions | DeclarativeStyleItemOptions;
-    /**
-     * Clones this style
+     * Clones this style. Does not pass the name property.
      */
     clone(result?: StyleItem): StyleItem;
     assign(styleItem: StyleItem): StyleItem;
-    equals(styleItem: StyleItem): boolean;
     /**
-     * gets a reference to this style by its name. should only be used for static styles, aka styles already part of the config
+     * Tests if two styleItems are equivalent. Does not match the name property (e.g. identifier)
      */
-    getReference(): Reference;
+    equals(styleItem: StyleItem): boolean;
     protected _styleChanged(): void;
     /**
      * unique Name
@@ -6528,13 +6532,6 @@ export class VectorStyleItem extends StyleItem {
      * @param section - one of fill, stroke, image
      */
     unset(section: string): void;
-    title: string | {
-        [key: string]: string;
-    };
-    /**
-     * Legend entries
-     */
-    legend: StyleItemLegendEntry[];
     supportedLayers: string[];
     /**
      * The 3D representation of this style
@@ -7459,6 +7456,14 @@ export class VcsApp {
     readonly destroyed: VcsEvent<void>;
     readonly contextAdded: any;
     readonly contextRemoved: any;
+    readonly dynamicContextId: string;
+    readonly mapClassRegistry: OverrideClassRegistry<VcsMap>;
+    readonly layerClassRegistry: OverrideClassRegistry<Layer>;
+    readonly styleClassRegistry: OverrideClassRegistry<StyleItem>;
+    readonly categoryClassRegistry: OverrideClassRegistry<Category<object | VcsObject>>;
+    readonly categoryItemClassRegistry: OverrideClassRegistry<any>;
+    readonly tileProviderClassRegistry: OverrideClassRegistry<TileProvider>;
+    readonly featureProviderClassRegistry: OverrideClassRegistry<AbstractFeatureProvider>;
     getContextById(id: string): Context;
     protected _parseContext(context: Context): Promise<void>;
     protected _setContextState(context: Context): Promise<void>;
@@ -7475,16 +7480,19 @@ 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 interface ContextLayerOptions extends LayerOptions {
+    style?: string | StyleItemOptions;
+    tileProvider?: TileProviderOptions;
+    featureProvider?: AbstractFeatureProviderOptions;
+}
+
+export function deserializeMap(vcsApp: VcsApp, mapConfig: VcsMapOptions): VcsMap | null;
 
-export function deserializeMap(vcsApp: VcsApp, mapConfig: VcsMapOptions): Promise<VcsMap | null>;
+export function deserializeViewPoint(viewPointObject: ViewPointOptions): null | ViewPoint;
 
-export function deserializeViewPoint(viewPointObject: ViewPointOptions): Promise<null | ViewPoint>;
+export function deserializeLayer(vcsApp: VcsApp, layerConfig: ContextLayerOptions): Layer | null;
 
-export function serializeLayer(vcsApp: VcsApp, layer: Layer): LayerOptions;
+export function serializeLayer(vcsApp: VcsApp, layer: Layer): ContextLayerOptions;
 
 export function getLayerIndex(current: Layer, previous: Layer, currentIndex: number): number | null;
 

package/index.js

@@ -9,14 +9,13 @@ import './src/cesium/cesiumVcsCameraPrimitive.js';
 export { default as AppBackedCategory } from './src/category/appBackedCategory.js';
 export { default as Category } from './src/category/category.js';
 export { default as CategoryCollection } from './src/category/categoryCollection.js';
-export { VcsClassRegistry, default as ClassRegistry } from './src/classRegistry.js';
+export { layerClassRegistry, tileProviderClassRegistry, featureProviderClassRegistry, mapClassRegistry, styleClassRegistry, categoryClassRegistry, getObjectFromClassRegistry, default as ClassRegistry } from './src/classRegistry.js';
 export { default as Context } from './src/context.js';
 export { default as AbstractFeatureProvider } from './src/featureProvider/abstractFeatureProvider.js';
 export { getGenericFeatureFromProvidedFeature } from './src/featureProvider/featureProviderHelpers.js';
 export { isProvidedFeature, showProvidedFeature } from './src/featureProvider/featureProviderSymbols.js';
 export { default as TileProviderFeatureProvider } from './src/featureProvider/tileProviderFeatureProvider.js';
 export { getFormat, default as WMSFeatureProvider } from './src/featureProvider/wmsFeatureProvider.js';
-export { styleCollection } from './src/globalCollections.js';
 export { default as AbstractInteraction } from './src/interaction/abstractInteraction.js';
 export { default as CoordinateAtPixel } from './src/interaction/coordinateAtPixel.js';
 export { default as EventHandler } from './src/interaction/eventHandler.js';
@@ -78,7 +77,6 @@ export { tiledLayerLoaded, globeLoaded } from './src/layer/tileLoadedHelper.js';
 export { default as MVTTileProvider } from './src/layer/tileProvider/mvtTileProvider.js';
 export { default as StaticGeoJSONTileProvider } from './src/layer/tileProvider/staticGeojsonTileProvider.js';
 export { mercatorResolutionsToLevel, rectangleToExtent, default as TileProvider } from './src/layer/tileProvider/tileProvider.js';
-export { default as factory } from './src/layer/tileProvider/tileProviderFactory.js';
 export { getURL, default as URLTemplateTileProvider } from './src/layer/tileProvider/urlTemplateTileProvider.js';
 export { default as TMSLayer } from './src/layer/tmsLayer.js';
 export { fvLastUpdated, globalHiderLastUpdated, updateFeatureVisibility, updateGlobalHider, synchronizeFeatureVisibilityWithSource, getGenericFeatureFromClickedObject } from './src/layer/vectorHelpers.js';
@@ -107,11 +105,12 @@ export { default as ObliqueProvider } from './src/oblique/obliqueProvider.js';
 export { default as ObliqueView } from './src/oblique/obliqueView.js';
 export { ObliqueViewDirection, obliqueViewDirectionNames, getDirectionName } from './src/oblique/obliqueViewDirection.js';
 export { getVersionFromImageJson, parseImageMeta, parseImageData, parseLegacyImageData } from './src/oblique/parseImageJson.js';
+export { default as OverrideClassRegistry } from './src/overrideClassRegistry.js';
 export { defaultDeclarativeStyle, default as DeclarativeStyleItem } from './src/style/declarativeStyleItem.js';
 export { getShapeFromOptions, shapeCategory } from './src/style/shapesCategory.js';
 export { getStyleOrDefaultStyle } from './src/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/style/styleHelpers.js';
-export { StyleType, referenceableStyleSymbol, default as StyleItem } from './src/style/styleItem.js';
+export { default as StyleItem } from './src/style/styleItem.js';
 export { OlcsGeometryType, vectorStyleSymbol, defaultVectorStyle, fromCesiumColor, default as VectorStyleItem } from './src/style/vectorStyleItem.js';
 export { embedIconsInStyle, default as writeStyle } from './src/style/writeStyle.js';
 export { default as ClippingObject } from './src/util/clipping/clippingObject.js';
@@ -142,6 +141,6 @@ export { default as SplitScreen } from './src/util/splitScreen.js';
 export { isSameOrigin } from './src/util/urlHelpers.js';
 export { propertyEqualsEpsilon, angleEqualsEpsilon, coordinateEqualsEpsilon, default as ViewPoint } from './src/util/viewpoint.js';
 export { getVcsAppById, default as VcsApp } from './src/vcsApp.js';
-export { contextIdSymbol, getObjectFromOptions, deserializeMap, deserializeViewPoint, serializeLayer, getLayerIndex, destroyCollection } from './src/vcsAppContextHelpers.js';
+export { contextIdSymbol, deserializeMap, deserializeViewPoint, deserializeLayer, serializeLayer, getLayerIndex, destroyCollection } from './src/vcsAppContextHelpers.js';
 export { default as VcsEvent } from './src/vcsEvent.js';
 export { default as VcsObject } from './src/vcsObject.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vcmap/core",
-  "version": "5.0.0-rc.8",
+  "version": "5.0.0-rc.9",
   "description": "",
   "main": "index.js",
   "type": "module",
@@ -73,7 +73,7 @@
   ],
   "dependencies": {
     "@types/rbush": "^3.0.0",
-    "@vcsuite/check": "^1.0.3",
+    "@vcsuite/check": "^1.1.2",
     "@vcsuite/logger": "^1.0.1",
     "@vcsuite/parsers": "^1.0.1",
     "fast-deep-equal": "^3.1.3",

package/src/category/appBackedCategory.js

@@ -1,11 +1,24 @@
 import Category from './category.js';
-import { VcsClassRegistry } from '../classRegistry.js';
+import { categoryClassRegistry } from '../classRegistry.js';
+import ViewPoint from '../util/viewpoint.js';
+import ObliqueCollection from '../oblique/obliqueCollection.js';
+import { deserializeLayer, deserializeMap } from '../vcsAppContextHelpers.js';
 
 /**
  * @typedef {CategoryOptions} AppBackedCategoryOptions
  * @property {string} collectionName
  */
 
+/**
+ * @type {Object<string, string>}
+ */
+const collectionNameMap = {
+  layers: 'layerClassRegistry',
+  styles: 'styleClassRegistry',
+  maps: 'mapClassRegistry',
+  categories: 'categoryClassRegistry',
+};
+
 /**
  * @class
  * @extends {Category<import("@vcmap/core").VcsObject>}
@@ -17,11 +30,33 @@ class AppBackedCategory extends Category {
    * @param {AppBackedCategoryOptions} options
    */
   constructor(options) {
-    options.typed = true;
+    options.classRegistryName = collectionNameMap[options.collectionName];
     super(options);
     this._collectionName = options.collectionName;
   }
 
+  /**
+   * @param {VcsObjectOptions} config
+   * @returns {Promise<import("@vcmap/core").VcsObject>}
+   * @protected
+   */
+  async _deserializeItem(config) {
+    if (!this._app) {
+      throw new Error('Cannot deserialize item before setting the vcApp');
+    }
+
+    if (this._collectionName === 'viewPoints') {
+      return new ViewPoint(config);
+    } else if (this._collectionName === 'obliqueCollections') {
+      return new ObliqueCollection(config);
+    } else if (this._collectionName === 'layers') {
+      return deserializeLayer(this._app, config);
+    } else if (this._collectionName === 'maps') {
+      return deserializeMap(this._app, config);
+    }
+    return super._deserializeItem(config);
+  }
+
   setApp(app) {
     super.setApp(app);
     this.setCollection(this._app[this._collectionName]);
@@ -38,4 +73,4 @@ class AppBackedCategory extends Category {
 }
 
 export default AppBackedCategory;
-VcsClassRegistry.registerClass(AppBackedCategory.className, AppBackedCategory);
+categoryClassRegistry.registerClass(AppBackedCategory.className, AppBackedCategory);

package/src/category/category.js

@@ -1,21 +1,21 @@
 import { check } from '@vcsuite/check';
 import { v4 as uuidv4 } from 'uuid';
-import { parseBoolean } from '@vcsuite/parsers';
 import { Feature } from 'ol';
-import { contextIdSymbol, destroyCollection, getObjectFromOptions } from '../vcsAppContextHelpers.js';
+import { contextIdSymbol, destroyCollection } from '../vcsAppContextHelpers.js';
 import makeOverrideCollection, { isOverrideCollection } from '../util/overrideCollection.js';
 import VcsObject from '../vcsObject.js';
 import VectorLayer from '../layer/vectorLayer.js';
 import IndexedCollection from '../util/indexedCollection.js';
 import { parseGeoJSON, writeGeoJSONFeature } from '../layer/geojsonHelpers.js';
 import Collection from '../util/collection.js';
-import { VcsClassRegistry } from '../classRegistry.js';
 import { getStyleOrDefaultStyle } from '../style/styleFactory.js';
+import { categoryClassRegistry, getObjectFromClassRegistry } from '../classRegistry.js';
+import OverrideClassRegistry from '../overrideClassRegistry.js';
 
 /**
  * @typedef {VcsObjectOptions} CategoryOptions
  * @property {string|Object<string, string>} [title]
- * @property {boolean} [typed=false]
+ * @property {string} [classRegistryName=''] - the class registry name on the current app to provide classes for this category. if provided, parseItems will deserialize using this class registry. See: {@link getObjectFromClassRegistry}.
  * @property {string|undefined} [featureProperty]
  * @property {VectorOptions} [layerOptions={}]
  * @property {Array<Object>} [items] - items are not evaluated by the constructor but passed to parseItem during deserialization.
@@ -85,7 +85,7 @@ class Category extends VcsObject {
     return {
       title: '',
       featureProperty: undefined,
-      typed: false,
+      classRegistryName: undefined,
       layerOptions: {},
       keyProperty: 'name',
       items: [],
@@ -113,10 +113,10 @@ class Category extends VcsObject {
      */
     this._featureProperty = options.featureProperty || defaultOptions.featureProperty;
     /**
-     * @type {boolean}
+     * @type {string}
      * @private
      */
-    this._typed = parseBoolean(options.typed, defaultOptions.typed);
+    this._classRegistryName = options.classRegistryName;
     /**
      * @type {VectorOptions}
      * @private
@@ -154,6 +154,12 @@ class Category extends VcsObject {
     this._contextRemovedListener = () => {};
   }
 
+  /**
+   * @type {string}
+   * @readonly
+   */
+  get classRegistryName() { return this._classRegistryName; }
+
   /**
    * The collection of this category.
    * @type {OverrideCollection<T>}
@@ -242,7 +248,12 @@ class Category extends VcsObject {
    */
   mergeOptions(options) {
     const defaultOptions = Category.getDefaultConfig();
-    checkMergeOptionOverride('typed', this._typed, defaultOptions.typed, options.typed);
+    checkMergeOptionOverride(
+      'classRegistryName',
+      this._classRegistryName,
+      defaultOptions.classRegistryName,
+      options.classRegistryName,
+    );
     checkMergeOptionOverride(
       'featureProperty',
       this._featureProperty,
@@ -284,7 +295,7 @@ class Category extends VcsObject {
         collection,
         this._getDynamicContextId.bind(this),
         this._serializeItem.bind(this),
-        this._typed ? getObjectFromOptions : null,
+        this._deserializeItem.bind(this),
       );
 
     [...this.collection].forEach((item) => { this._itemAdded(item); });
@@ -321,6 +332,22 @@ class Category extends VcsObject {
     }
   }
 
+  /**
+   * @protected
+   * @param {*} config
+   * @returns {Promise<T>} // XXX should this still be async?
+   */
+  async _deserializeItem(config) {
+    if (!this._app) {
+      throw new Error('Cannot deserialize item before setting the vcApp');
+    }
+    const classRegistry = this._classRegistryName ? this._app[this._classRegistryName] : null;
+    if (classRegistry && classRegistry instanceof OverrideClassRegistry) {
+      return getObjectFromClassRegistry(classRegistry, config);
+    }
+    return config;
+  }
+
   /**
    * @protected
    * @param {T} item
@@ -371,4 +398,4 @@ class Category extends VcsObject {
 }
 
 export default Category;
-VcsClassRegistry.registerClass(Category.className, Category);
+categoryClassRegistry.registerClass(Category.className, Category);

package/src/category/categoryCollection.js

@@ -1,8 +1,8 @@
 import { getLogger as getLoggerByName } from '@vcsuite/logger';
 import Category from './category.js';
-import { getObjectFromOptions } from '../vcsAppContextHelpers.js';
 import './appBackedCategory.js';
 import IndexedCollection from '../util/indexedCollection.js';
+import { getObjectFromClassRegistry } from '../classRegistry.js';
 
 /**
  * @returns {import("@vcsuite/logger").Logger}
@@ -120,7 +120,7 @@ class CategoryCollection extends IndexedCollection {
       category = this.getByKey(options.name);
       category.mergeOptions(options);
     } else {
-      category = await getObjectFromOptions(options);
+      category = await getObjectFromClassRegistry(this._app.categoryClassRegistry, options);
       if (category) {
         if (this.add(category) == null) {
           return null;
@@ -129,7 +129,7 @@ class CategoryCollection extends IndexedCollection {
     }
 
     if (!category) {
-      throw new Error(`Category ${options.name} with type ${category.type} could not be created`);
+      throw new Error(`Category ${options.name} with type ${options.type} could not be created`);
     }
     return category;
   }