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

package/src/layer/tileProvider/staticGeojsonTileProvider.js

@@ -1,10 +1,11 @@
 import { parseGeoJSON } from '../geojsonHelpers.js';
 import TileProvider from './tileProvider.js';
 import { requestJson } from '../../util/fetch.js';
+import { tileProviderClassRegistry } from '../../classRegistry.js';
 
 /**
- * @typedef {TileProviderOptions} StaticGeojsonTileProviderOptions
- * @property {string} url geojson
+ * @typedef {TileProviderOptions} StaticGeoJSONTileProviderOptions
+ * @property {string} url - url to the geojson
  * @api
  */
 
@@ -24,7 +25,7 @@ class StaticGeoJSONTileProvider extends TileProvider {
   static get className() { return 'StaticGeoJSONTileProvider'; }
 
   /**
-   * @returns {StaticGeojsonTileProviderOptions}
+   * @returns {StaticGeoJSONTileProviderOptions}
    */
   static getDefaultOptions() {
     return {
@@ -35,7 +36,7 @@ class StaticGeoJSONTileProvider extends TileProvider {
   }
 
   /**
-   * @param {StaticGeojsonTileProviderOptions} options
+   * @param {StaticGeoJSONTileProviderOptions} options
    */
   constructor(options) {
     const defaultOptions = StaticGeoJSONTileProvider.getDefaultOptions();
@@ -62,6 +63,20 @@ class StaticGeoJSONTileProvider extends TileProvider {
     const { features } = parseGeoJSON(data, { dynamicStyle: true });
     return features;
   }
+
+  /**
+   * @returns {StaticGeoJSONTileProviderOptions}
+   */
+  toJSON() {
+    const config = /** @type {StaticGeoJSONTileProviderOptions} */ (super.toJSON());
+    delete config.baseLevels;
+
+    if (this.url) {
+      config.url = this.url;
+    }
+    return config;
+  }
 }
 
 export default StaticGeoJSONTileProvider;
+tileProviderClassRegistry.registerClass(StaticGeoJSONTileProvider.className, StaticGeoJSONTileProvider);

package/src/layer/tileProvider/tileProvider.js

@@ -12,6 +12,7 @@ import {
 } from '../../util/projection.js';
 import VcsObject from '../../vcsObject.js';
 import VcsEvent from '../../vcsEvent.js';
+import { tileProviderClassRegistry } from '../../classRegistry.js';
 
 /**
  * @typedef {Object} tileProviderRTreeEntry
@@ -538,13 +539,20 @@ class TileProvider extends VcsObject {
       config.tileCacheSize = this.tileCacheSize;
     }
 
-    if (defaultOptions.baseLevels !== this.baseLevels) {
+    if (!(
+      this.baseLevels.length === defaultOptions.baseLevels.length &&
+      this.baseLevels.every(level => defaultOptions.baseLevels.includes(level))
+    )) {
       config.baseLevels = this.baseLevels.slice();
     }
 
     if (defaultOptions.trackFeaturesToTiles !== this.trackFeaturesToTiles) {
       config.trackFeaturesToTiles = this.trackFeaturesToTiles;
     }
+
+    if (defaultOptions.allowTileAggregation !== this.allowTileAggregation) {
+      config.allowTileAggregation = this.allowTileAggregation;
+    }
     return config;
   }
 
@@ -582,3 +590,4 @@ class TileProvider extends VcsObject {
 }
 
 export default TileProvider;
+tileProviderClassRegistry.registerClass(TileProvider.className, TileProvider);

package/src/layer/tileProvider/urlTemplateTileProvider.js

@@ -3,6 +3,7 @@ import { parseGeoJSON } from '../geojsonHelpers.js';
 import TileProvider from './tileProvider.js';
 import { getCurrentLocale } from '../../util/locale.js';
 import { requestJson } from '../../util/fetch.js';
+import { tileProviderClassRegistry } from '../../classRegistry.js';
 
 /**
  * @typedef {TileProviderOptions} URLTemplateTileProviderOptions
@@ -101,6 +102,20 @@ class URLTemplateTileProvider extends TileProvider {
     const { features } = parseGeoJSON(data, { dynamicStyle: true });
     return features;
   }
+
+  /**
+   * @returns {URLTemplateTileProviderOptions}
+   */
+  toJSON() {
+    const config = /** @type {URLTemplateTileProviderOptions} */ (super.toJSON());
+
+    if (this.url) {
+      config.url = this.url;
+    }
+
+    return config;
+  }
 }
 
 export default URLTemplateTileProvider;
+tileProviderClassRegistry.registerClass(URLTemplateTileProvider.className, URLTemplateTileProvider);

package/src/layer/tmsLayer.js

@@ -3,7 +3,7 @@ import OpenlayersMap from '../map/openlayersMap.js';
 import CesiumMap from '../map/cesiumMap.js';
 import TmsOpenlayersImpl from './openlayers/tmsOpenlayersImpl.js';
 import TmsCesiumImpl from './cesium/tmsCesiumImpl.js';
-import { VcsClassRegistry } from '../classRegistry.js';
+import { layerClassRegistry } from '../classRegistry.js';
 
 /**
  * @typedef {RasterLayerOptions} TMSOptions
@@ -117,5 +117,5 @@ class TMSLayer extends RasterLayer {
   }
 }
 
-VcsClassRegistry.registerClass(TMSLayer.className, TMSLayer);
+layerClassRegistry.registerClass(TMSLayer.className, TMSLayer);
 export default TMSLayer;

package/src/layer/vectorLayer.js

@@ -26,9 +26,9 @@ import VectorObliqueImpl from './oblique/vectorObliqueImpl.js';
 import ObliqueMap from '../map/obliqueMap.js';
 import CesiumMap from '../map/cesiumMap.js';
 import { originalStyle, updateOriginalStyle } from './featureVisibility.js';
-import StyleItem, { referenceableStyleSymbol, StyleType } from '../style/styleItem.js';
+import StyleItem from '../style/styleItem.js';
 import { getGenericFeatureFromClickedObject } from './vectorHelpers.js';
-import { VcsClassRegistry } from '../classRegistry.js';
+import { layerClassRegistry } from '../classRegistry.js';
 
 /**
  * @typedef {FeatureLayerOptions} VectorOptions
@@ -213,17 +213,12 @@ class VectorLayer extends FeatureLayer {
     });
 
     let initialStyle = options.style;
-    if (options.activeStyleName) {
-      initialStyle = {
-        type: StyleType.REFERENCE,
-        name: options.activeStyleName,
-      };
-    } else if (options.style instanceof StyleItem) {
-      initialStyle = options.style.getOptions();
+    if (options.style instanceof StyleItem) {
+      initialStyle = options.style.toJSON();
     }
 
     /**
-     * @type {Reference|StyleItemOptions|string}
+     * @type {StyleItemOptions}
      * @private
      */
     this._initialStyle = initialStyle;
@@ -344,7 +339,7 @@ class VectorLayer extends FeatureLayer {
   }
 
   /**
-   * @param {(Reference|DeclarativeStyleItemOptions|VectorStyleItemOptions|import("@vcmap/core").StyleItem|string)=} styleOptions
+   * @param {(DeclarativeStyleItemOptions|VectorStyleItemOptions|import("@vcmap/core").StyleItem)=} styleOptions
    * @param {import("@vcmap/core").VectorStyleItem=} defaultStyle
    * @returns {import("@vcmap/core").StyleItem}
    */
@@ -354,7 +349,7 @@ class VectorLayer extends FeatureLayer {
 
   /**
    * sets the style of this layer
-   * @param {import("ol/style/Style").default|import("ol/style/Style").StyleFunction|import("@vcmap/core").StyleItem|string} style
+   * @param {import("ol/style/Style").default|import("ol/style/Style").StyleFunction|import("@vcmap/core").StyleItem} style
    * @param {boolean=} silent
    */
   setStyle(style, silent) {
@@ -594,9 +589,7 @@ class VectorLayer extends FeatureLayer {
     }
 
     if (this.highlightStyle) {
-      config.highlightStyle = this.highlightStyle[referenceableStyleSymbol] ?
-        this.highlightStyle.getReference() :
-        this.highlightStyle.getOptions();
+      config.highlightStyle = this.highlightStyle.toJSON();
     }
 
     if (this.isDynamic !== defaultOptions.isDynamic) {
@@ -608,8 +601,6 @@ class VectorLayer extends FeatureLayer {
       config.vectorProperties = vectorPropertiesConfig;
     }
 
-    // XXX missing style
-
     return config;
   }
 
@@ -628,5 +619,5 @@ class VectorLayer extends FeatureLayer {
   }
 }
 
-VcsClassRegistry.registerClass(VectorLayer.className, VectorLayer);
+layerClassRegistry.registerClass(VectorLayer.className, VectorLayer);
 export default VectorLayer;

package/src/layer/vectorTileLayer.js

@@ -12,10 +12,10 @@ import { FeatureVisibilityAction, globalHidden, hidden, highlighted } from './fe
 import { getStylesArray } from '../util/featureconverter/convert.js';
 import { vcsLayerName } from './layerSymbols.js';
 import TileProviderFeatureProvider from '../featureProvider/tileProviderFeatureProvider.js';
-import tileProviderFactory from './tileProvider/tileProviderFactory.js';
 import { getGenericFeatureFromClickedObject } from './vectorHelpers.js';
 import { originalFeatureSymbol } from './vectorSymbols.js';
-import { VcsClassRegistry } from '../classRegistry.js';
+import { getObjectFromClassRegistry, layerClassRegistry, tileProviderClassRegistry } from '../classRegistry.js';
+import TileProvider from './tileProvider/tileProvider.js';
 
 /**
  * synchronizes featureVisibility Symbols on the feature;
@@ -44,7 +44,7 @@ function synchronizeFeatureVisibility(featureVisibility, globalHider, feature) {
 
 /**
  * @typedef {FeatureLayerOptions} VectorTileOptions
- * @property {TileProviderOptions} tileProvider
+ * @property {TileProviderOptions|import("@vcmap/core").TileProvider} tileProvider
  * @property {VectorStyleItemOptions|import("@vcmap/core").VectorStyleItem|undefined} highlightStyle
  * @property {VectorPropertiesOptions|undefined} vectorProperties
  * @property {number|undefined} minLevel used to restrict the zoom level visibility (minlevel does not allow rendering above tileProvider baseLevel)
@@ -132,17 +132,13 @@ class VectorTileLayer extends FeatureLayer {
       ...options.vectorProperties,
     });
 
-    /**
-     * @type {TileProviderOptions}
-     * @private
-     */
-    this._tileProviderOptions = options.tileProvider;
-
     /**
      * @type {import("@vcmap/core").TileProvider}
      * @api
      */
-    this.tileProvider = undefined;
+    this.tileProvider = options.tileProvider instanceof TileProvider ? // XXX this now throws if not passing in a tileProvider.
+      options.tileProvider :
+      getObjectFromClassRegistry(tileProviderClassRegistry, options.tileProvider);
 
     /**
      * @type {number|undefined}
@@ -187,21 +183,19 @@ class VectorTileLayer extends FeatureLayer {
    * @returns {Promise<void>}
    */
   async initialize() {
-    await super.initialize();
-    if (!this.tileProvider) {
-      this.tileProvider = await tileProviderFactory(this._tileProviderOptions);
-      // this.tileProvider = await tileProviderFactory(this._tileProviderOptions);
+    if (!this.initialized) {
       this._tileLoadEventListener =
         this.tileProvider.tileLoadedEvent.addEventListener(event => this._handleTileLoaded(event));
       this._vectorPropertiesChangedListener =
         this.vectorProperties.propertyChanged.addEventListener(() => {
           this.reload();
         });
-      this.featureProvider = new TileProviderFeatureProvider(this.name, {
+      this.featureProvider = new TileProviderFeatureProvider(this.name, { // XXX this overwrites
         tileProvider: this.tileProvider,
         vectorProperties: this.vectorProperties,
       });
     }
+    await super.initialize();
   }
 
 
@@ -392,7 +386,7 @@ class VectorTileLayer extends FeatureLayer {
   }
 
   /**
-   * @param {(Reference|DeclarativeStyleItemOptions|VectorStyleItemOptions|import("@vcmap/core").StyleItem|string)=} styleOptions
+   * @param {(DeclarativeStyleItemOptions|VectorStyleItemOptions|import("@vcmap/core").StyleItem)=} styleOptions
    * @param {VectorStyleItem=} defaultStyle
    * @returns {import("@vcmap/core").StyleItem}
    */
@@ -466,15 +460,12 @@ class VectorTileLayer extends FeatureLayer {
     }
 
     if (this.tileProvider) {
-      const tileProviderConfig = this.tileProvider.toJSON();
-      config.tileProvider = tileProviderConfig;
-    } else if (this._tileProviderOptions) {
-      config.tileProvider = this._tileProviderOptions;
+      config.tileProvider = this.tileProvider.toJSON();
     }
 
     return config;
   }
 }
 
-VcsClassRegistry.registerClass(VectorTileLayer.className, VectorTileLayer);
+layerClassRegistry.registerClass(VectorTileLayer.className, VectorTileLayer);
 export default VectorTileLayer;

package/src/layer/wfsLayer.js

@@ -1,7 +1,7 @@
 import WFSFormat from 'ol/format/WFS.js';
 import VectorLayer from './vectorLayer.js';
 import Projection from '../util/projection.js';
-import { VcsClassRegistry } from '../classRegistry.js';
+import { layerClassRegistry } from '../classRegistry.js';
 import { requestJson } from '../util/fetch.js';
 
 /**
@@ -161,5 +161,5 @@ class WFSLayer extends VectorLayer {
   }
 }
 
-VcsClassRegistry.registerClass(WFSLayer.className, WFSLayer);
+layerClassRegistry.registerClass(WFSLayer.className, WFSLayer);
 export default WFSLayer;

package/src/layer/wmsLayer.js

@@ -7,7 +7,7 @@ import WmsCesiumImpl from './cesium/wmsCesiumImpl.js';
 import OpenlayersMap from '../map/openlayersMap.js';
 import WmsOpenlayersImpl from './openlayers/wmsOpenlayersImpl.js';
 import Extent from '../util/extent.js';
-import { VcsClassRegistry } from '../classRegistry.js';
+import { layerClassRegistry } from '../classRegistry.js';
 
 /**
  * @typedef {RasterLayerImplementationOptions} WMSImplementationOptions
@@ -266,5 +266,5 @@ class WMSLayer extends RasterLayer {
   }
 }
 
-VcsClassRegistry.registerClass(WMSLayer.className, WMSLayer);
+layerClassRegistry.registerClass(WMSLayer.className, WMSLayer);
 export default WMSLayer;

package/src/layer/wmtsLayer.js

@@ -5,7 +5,7 @@ import OpenlayersMap from '../map/openlayersMap.js';
 import CesiumMap from '../map/cesiumMap.js';
 import WmtsOpenlayersImpl from './openlayers/wmtsOpenlayersImpl.js';
 import WmtsCesiumImpl from './cesium/wmtsCesiumImpl.js';
-import { VcsClassRegistry } from '../classRegistry.js';
+import { layerClassRegistry } from '../classRegistry.js';
 
 /**
  * @typedef {RasterLayerOptions} WMTSOptions
@@ -230,6 +230,6 @@ class WMTSLayer extends RasterLayer {
   }
 }
 
-VcsClassRegistry.registerClass(WMTSLayer.className, WMTSLayer);
+layerClassRegistry.registerClass(WMTSLayer.className, WMTSLayer);
 export default WMTSLayer;
 

package/src/map/baseOLMap.js

@@ -5,7 +5,7 @@ import { defaults as defaultInteractions } from 'ol/interaction.js';
 import VcsMap from './vcsMap.js';
 import { vcsLayerName } from '../layer/layerSymbols.js';
 import { ModificationKeyType, PointerEventType, PointerKeyType } from '../interaction/interactionType.js';
-import { VcsClassRegistry } from '../classRegistry.js';
+import { mapClassRegistry } from '../classRegistry.js';
 
 /**
  * @param {import("ol/Collection").default<import("ol/layer/Layer").default>} layers
@@ -253,5 +253,5 @@ class BaseOLMap extends VcsMap {
   }
 }
 
-VcsClassRegistry.registerClass(BaseOLMap.className, BaseOLMap);
+mapClassRegistry.registerClass(BaseOLMap.className, BaseOLMap);
 export default BaseOLMap;

package/src/map/cesiumMap.js

@@ -38,7 +38,7 @@ import { getHeightFromTerrainProvider } from '../layer/terrainHelpers.js';
 import { vcsLayerName } from '../layer/layerSymbols.js';
 import { ModificationKeyType, PointerEventType, PointerKeyType } from '../interaction/interactionType.js';
 import CameraLimiter from './cameraLimiter.js';
-import { VcsClassRegistry } from '../classRegistry.js';
+import { mapClassRegistry } from '../classRegistry.js';
 
 /**
  * @typedef {VcsMapOptions} CesiumMapOptions
@@ -1173,5 +1173,5 @@ class CesiumMap extends VcsMap {
   }
 }
 
-VcsClassRegistry.registerClass(CesiumMap.className, CesiumMap);
+mapClassRegistry.registerClass(CesiumMap.className, CesiumMap);
 export default CesiumMap;

package/src/map/obliqueMap.js

@@ -13,7 +13,7 @@ import { ObliqueViewDirection as ViewDirection } from '../oblique/obliqueViewDir
 import ObliqueProvider from '../oblique/obliqueProvider.js';
 import ObliqueCollection from '../oblique/obliqueCollection.js';
 import { transformFromImage } from '../oblique/helpers.js';
-import { VcsClassRegistry } from '../classRegistry.js';
+import { mapClassRegistry } from '../classRegistry.js';
 import DefaultObliqueCollection from '../oblique/defaultObliqueCollection.js';
 
 /**
@@ -518,5 +518,5 @@ class ObliqueMap extends BaseOLMap {
   }
 }
 
-VcsClassRegistry.registerClass(ObliqueMap.className, ObliqueMap);
+mapClassRegistry.registerClass(ObliqueMap.className, ObliqueMap);
 export default ObliqueMap;

package/src/map/openlayersMap.js

@@ -7,7 +7,7 @@ import { parseBoolean } from '@vcsuite/parsers';
 import ViewPoint from '../util/viewpoint.js';
 import BaseOLMap from './baseOLMap.js';
 import VcsMap from './vcsMap.js';
-import { VcsClassRegistry } from '../classRegistry.js';
+import { mapClassRegistry } from '../classRegistry.js';
 
 /**
  * @typedef {VcsMapOptions} OpenlayersOptions
@@ -204,5 +204,5 @@ class OpenlayersMap extends BaseOLMap {
   }
 }
 
-VcsClassRegistry.registerClass(OpenlayersMap.className, OpenlayersMap);
+mapClassRegistry.registerClass(OpenlayersMap.className, OpenlayersMap);
 export default OpenlayersMap;

package/src/map/vcsMap.js

@@ -5,7 +5,7 @@ import LayerCollection from '../util/layerCollection.js';
 import MapState from './mapState.js';
 import { vcsLayerName } from '../layer/layerSymbols.js';
 import VcsEvent from '../vcsEvent.js';
-import { VcsClassRegistry } from '../classRegistry.js';
+import { mapClassRegistry } from '../classRegistry.js';
 
 /**
  * @namespace maps
@@ -522,5 +522,5 @@ class VcsMap extends VcsObject {
   }
 }
 
-VcsClassRegistry.registerClass(VcsMap.className, VcsMap);
+mapClassRegistry.registerClass(VcsMap.className, VcsMap);
 export default VcsMap;

package/src/overrideClassRegistry.js

@@ -0,0 +1,204 @@
+import { check } from '@vcsuite/check';
+import { getLogger } from '@vcsuite/logger';
+import VcsEvent from './vcsEvent.js';
+
+/**
+ * @returns {import("@vcsuite/logger").Logger}
+ */
+function logger() {
+  return getLogger('OverrideClassRegistry');
+}
+
+/**
+ * @class
+ * @template {Object|import("@vcmap/core").VcsObject} T
+ */
+class OverrideClassRegistry {
+  /**
+   * @param {import("@vcmap/core").ClassRegistry<T>} coreClassRegistry
+   */
+  constructor(coreClassRegistry) {
+    this._coreClassRegistry = coreClassRegistry;
+    /**
+     * @type {Map<string, { contextId: string, ctor: function(new: T, ...*) }>}
+     * @private
+     */
+    this._classMap = new Map();
+    /**
+     * @type {Map<string, Array<{ contextId: string, ctor: function(new: T, ...*) }>>}
+     * @private
+     */
+    this._classShadows = new Map();
+    /**
+     * Called if a class was replaced. Is passed the className
+     * @type {VcsEvent<string>}
+     */
+    this.replaced = new VcsEvent();
+    /**
+     * Called if a class was removed. Is passed the className
+     * @type {VcsEvent<string>}
+     */
+    this.removed = new VcsEvent();
+  }
+
+  /**
+   * @returns {Array<string>}
+   */
+  getClassNames() {
+    return [...new Set([...this._classMap.keys(), ...this._coreClassRegistry.getClassNames()])];
+  }
+
+  /**
+   * Register a class for a given context by name. If the class already exists, it will be replaced and replaced called with the classeName.
+   * @param {string} contextId
+   * @param {string} className
+   * @param {function(new: T, ...*)} ctor
+   */
+  registerClass(contextId, className, ctor) {
+    check(contextId, String);
+    check(className, String);
+    check(ctor, Function);
+
+    const entry = {
+      contextId,
+      ctor,
+    };
+
+    const replaced = this.hasClass(className);
+
+    if (this._classMap.has(className)) {
+      if (!this._classShadows.has(className)) {
+        this._classShadows.set(className, []);
+      }
+      this._classShadows.get(className).push(this._classMap.get(className));
+    }
+    this._classMap.set(className, entry);
+
+    if (replaced) {
+      this.replaced.raiseEvent(className);
+    }
+  }
+
+  /**
+   * 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.
+   * @param {string} contextId
+   * @param {string} className
+   */
+  unregisterClass(contextId, className) {
+    check(contextId, String);
+    check(className, String);
+
+    if (this._classShadows.has(className)) {
+      const shadowsArray = this._classShadows.get(className);
+      const newShadowsArray = shadowsArray.filter(e => e.contextId !== contextId);
+      if (newShadowsArray.length === 0) {
+        this._classShadows.delete(className);
+      } else if (newShadowsArray.length !== shadowsArray.length) {
+        this._classShadows.set(className, newShadowsArray);
+      }
+    }
+
+    if (
+      this._classMap.has(className) &&
+      this._classMap.get(className).contextId === contextId
+    ) {
+      this._classMap.delete(className);
+      if (this._classShadows.has(className)) {
+        this._classMap.set(className, this._classShadows.get(className).pop());
+        if (this._classShadows.get(className).length === 0) {
+          this._classShadows.delete(className);
+        }
+        this.replaced.raiseEvent(className);
+      } else if (this._coreClassRegistry.hasClass(className)) {
+        this.replaced.raiseEvent(className);
+      } else {
+        this.removed.raiseEvent(className);
+      }
+    }
+  }
+
+  /**
+   * Gets the constructor for a registered class or undefined, if no such class was registerd
+   * @param {string} className
+   * @returns {function(new: T, ...*)|undefined}
+   * @api
+   */
+  getClass(className) {
+    check(className, String);
+
+    if (this._classMap.has(className)) {
+      return this._classMap.get(className).ctor;
+    }
+    return this._coreClassRegistry.getClass(className);
+  }
+
+  /**
+   * @param {string} className
+   * @returns {boolean}
+   */
+  hasClass(className) {
+    check(className, String);
+
+    return this._classMap.has(className) || this._coreClassRegistry.hasClass(className);
+  }
+
+  /**
+   * Create an object of the given className. The constructor is passed args.
+   * @param {string} className
+   * @param {...*} args
+   * @returns {T}
+   * @api
+   */
+  create(className, ...args) {
+    check(className, String);
+
+    const Ctor = this.getClass(className);
+    if (!Ctor) {
+      logger().error(`could not find constructor ${className}`);
+      return undefined;
+    }
+    return new Ctor(...args);
+  }
+
+  /**
+   * 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.
+   * @param {Object} options
+   * @param {...*} args
+   * @returns {T}
+   */
+  createFromTypeOptions(options, ...args) {
+    check(options, { type: String });
+
+    return this.create(options.type, options, ...args);
+  }
+
+  /**
+   * 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.
+   * @param {string} contextId
+   */
+  removeContext(contextId) {
+    check(contextId, String);
+
+    this._classMap.forEach((cb, className) => {
+      this.unregisterClass(contextId, className);
+    });
+  }
+
+  /**
+   * Destroys the override class registry
+   */
+  destroy() {
+    this._coreClassRegistry = null;
+    this._classMap.clear();
+    this._classShadows.clear();
+    this.replaced.destroy();
+    this.removed.destroy();
+  }
+}
+
+export default OverrideClassRegistry;