@vcmap/ui 5.0.2 → 5.1.0-rc.2

package/src/manager/collectionManager/{collectionComponent.js → collectionComponentClass.js}

@@ -1,28 +1,68 @@
 import { IndexedCollection, isOverrideCollection } from '@vcmap/core';
 import { getLogger } from '@vcsuite/logger';
 import { v4 as uuidv4 } from 'uuid';
-import { computed, ref } from 'vue';
-import { parseNumber } from '@vcsuite/parsers';
+import { computed, ref, watch } from 'vue';
+import { parseBoolean, parseNumber } from '@vcsuite/parsers';
 import { validateAction } from '../../components/lists/VcsActionList.vue';
 import { sortByWeight } from '../buttonManager.js';
+import {
+  createListItemBulkAction,
+  createListItemDeleteAction,
+  createListItemRenameAction,
+} from '../../actions/listActions.js';
+import { sortByOwner } from '../navbarManager.js';
 
 /**
  * @typedef {Object} CollectionComponentUiOptions
  * @property {string} [id]
  * @property {string} [title]
- * @property {boolean} [draggable] - only supported for IndexedCollections
- * @property {boolean} [selectable]
- * @property {boolean} [singleSelect]
+ * @property {boolean} [draggable=false] - only supported for IndexedCollections
+ * @property {boolean} [renamable=false] - adds actions to rename items from list. Sets a default titleChanged callback on all list items, which can be overwritten in the mapping function, if necessary.
+ * @property {boolean} [removable=false] - adds actions to remove items from list. Also adds a header action to delete selected, if selectable is set to true.
+ * @property {boolean} [selectable=false]
+ * @property {boolean} [singleSelect=false]
  * @property {number} [overflowCount=2] - number of header action buttons rendered until overflow
  * @property {number} [limit=10] - limit number of items in rendered list (more items are rendered in extra window)
  */
 
 /**
- * @typedef {CollectionComponentUiOptions} CollectionComponentOptions
- * @property {import("@vcmap/core").Collection<T>} collection
+ * @typedef {CollectionComponentUiOptions & {
+ *   collection: import("@vcmap/core").Collection<T>
+ * }} CollectionComponentClassOptions
  * @template {Object} T
  */
 
+/**
+ * @typedef {import("../../components/lists/VcsList.vue").VcsListItem & {
+ *   actions: Array<import("../../actions/actionHelper.js").VcsAction & { weight?: number }>,
+ *   clickedCallbacks: Array<function(PointerEvent):void>,
+ *   destroy: function():void|undefined
+ *   destroyFunctions: Array<function():void>
+ * }} CollectionComponentListItem
+ */
+
+/**
+ * @param {CollectionComponentListItem} listItem
+ */
+function destroyListItem(listItem) {
+  listItem.destroyFunctions.forEach((cb) => cb());
+  listItem.destroy?.();
+}
+
+/**
+ * Renames the title of an item for VcsObject based items.
+ * @param {import("@vcmap/core").VcsObject} item
+ * @param {import("../../components/lists/VcsList").VcsListItem} listItem
+ * @param {string} newTitle
+ */
+function titleChanged(item, listItem, newTitle) {
+  if (!item.properties) {
+    item.properties = {};
+  }
+  item.properties.title = newTitle;
+  listItem.title = newTitle;
+}
+
 /**
  * Manages one collection and creates a mirrored items array with ListItems.
  * Listens to all collection events and synchronizes changes to the items array.
@@ -30,15 +70,15 @@ import { sortByWeight } from '../buttonManager.js';
  * @class
  * @template {Object|import("@vcmap/core").VcsObject} T
  */
-class CollectionComponent {
+class CollectionComponentClass {
   /**
-   * @param {CollectionComponentOptions} options
-   * @param {string|vcsAppSymbol} owner
+   * @param {CollectionComponentClassOptions<T>} options
+   * @param {string|import("../../pluginHelper.js").vcsAppSymbol} owner
    */
   constructor(options, owner) {
     if (!options?.collection?.uniqueKey) {
       throw new Error(
-        'CollectionComponentOptions requires a collection with mandatory key!',
+        'CollectionComponentClassOptions requires a collection with mandatory key!',
       );
     }
 
@@ -80,11 +120,19 @@ class CollectionComponent {
     /**
      * @type {import("vue").Ref<boolean>}
      */
-    this.selectable = ref(options.selectable);
+    this.renamable = ref(parseBoolean(options.renamable, false));
+    /**
+     * @type {import("vue").Ref<boolean>}
+     */
+    this.removable = ref(parseBoolean(options.removable, false));
     /**
      * @type {import("vue").Ref<boolean>}
      */
-    this.singleSelect = ref(options.singleSelect);
+    this.selectable = ref(parseBoolean(options.selectable));
+    /**
+     * @type {import("vue").Ref<boolean>}
+     */
+    this.singleSelect = ref(parseBoolean(options.singleSelect));
     /**
      * @type {string|vcsAppSymbol}
      * @private
@@ -92,29 +140,53 @@ class CollectionComponent {
     this._owner = owner;
 
     /**
-     * @type {import("vue").Ref<Array<OwnedAction>>}
+     * @type {import("vue").Ref<Array<import("./collectionManager.js").OwnedAction>>}
      */
     this._actions = ref([]);
     /**
-     * @type {Array<ItemMapping<*>>}
+     * @type {Array<import("./collectionManager.js").ItemMapping<T>>}
      * @private
      */
     this._itemMappings = [];
     /**
-     * @type {Array<ItemFilter<*>>}
+     * @type {Array<import("./collectionManager.js").ItemFilter<T>>}
      * @private
      */
     this._itemFilters = [];
     /**
-     * @type {import("vue").Ref<Array<import("@vcmap/ui").VcsListItem & { destroy: (function():void)|undefined }>>}
+     * @type {import("vue").Ref<Array<CollectionComponentListItem>>}
      * @private
      */
     this._listItems = ref([]);
     /**
-     * @type {import("vue").Ref<Array<import("@vcmap/ui").VcsListItem & { destroy: (function():void)|undefined }>>}
+     * @type {import("vue").Ref<Array<CollectionComponentListItem>>}
      */
     this.selection = ref([]);
 
+    this._resetWatchers = [
+      watch(this.renamable, () => this.reset()),
+      watch([this.removable, this.selectable], () => {
+        if (this.removable.value && this.selectable.value) {
+          this._addBulkDeleteAction();
+        } else {
+          this._removeBulkDeleteAction();
+        }
+        this.reset();
+      }),
+      watch(this._draggable, () => {
+        if (!(this._collection instanceof IndexedCollection)) {
+          getLogger('CollectionComponentClass').warning(
+            'draggable can only be set to IndexedCollections!',
+          );
+          this._draggable.value = false;
+        }
+      }),
+    ];
+    this._destroyBulkDelete = () => {};
+    if (this.removable.value && this.selectable.value) {
+      this._addBulkDeleteAction();
+    }
+
     this._listeners = [
       this._collection.added.addEventListener(this._handleItemAdded.bind(this)),
       this._collection.removed.addEventListener(
@@ -124,9 +196,9 @@ class CollectionComponent {
 
     if (this._collection[isOverrideCollection]) {
       this._listeners.push(
-        this._collection.replaced.addEventListener((replacedEvent) => {
-          this._handleItemRemoved(replacedEvent.old);
-        }),
+        this._collection.replaced.addEventListener(
+          this._handleItemReplaced.bind(this),
+        ),
       );
     }
 
@@ -137,29 +209,25 @@ class CollectionComponent {
         ),
       );
     }
-
     this.reset();
   }
 
   /**
    * @type {string}
-   * @readonly
    */
   get id() {
     return this._id;
   }
 
   /**
-   * @type {import("@vcmap/core").Collection<*>}
-   * @readonly
+   * @type {import("@vcmap/core").Collection<T>}
    */
   get collection() {
     return this._collection;
   }
 
   /**
-   * @type {import("vue").Ref<Array<import("@vcmap/ui").VcsListItem & { destroy: (function():void)|undefined }>>}
-   * @readonly
+   * @type {import("vue").Ref<Array<CollectionComponentListItem>>}
    */
   get items() {
     return this._listItems;
@@ -167,7 +235,6 @@ class CollectionComponent {
 
   /**
    * @type {import("vue").Ref<boolean>}
-   * @readonly
    */
   get draggable() {
     return this._draggable;
@@ -175,36 +242,66 @@ class CollectionComponent {
 
   /**
    * @param {boolean} value
+   * @deprecated
    */
   set draggable(value) {
-    if (this._collection instanceof IndexedCollection) {
-      getLogger('CollectionComponent').warn(
-        'draggable can only be set to IndexedCollections!',
-      );
-      return;
-    }
+    getLogger('CollectionComponentClass').deprecate('set draggable');
     this._draggable.value = value;
   }
 
   /**
-   * @type {string|vcsAppSymbol}
-   * @readonly
+   * @type {string|import("../../pluginHelper.js").vcsAppSymbol}
    */
   get owner() {
     return this._owner;
   }
 
   /**
-   * @returns {import("vue").ComputedRef<VcsAction[]>}
+   * @returns {import("vue").ComputedRef<import("../../actions/actionHelper.js").VcsAction[]>}
    */
   getActions() {
     return computed(() => this._actions.value.map(({ action }) => action));
   }
 
   /**
-   * uses the itemMappings to transform the given Item to an VcsListItem usable in the VcsList
+   * @private
+   */
+  _addBulkDeleteAction() {
+    const { action, destroy } = createListItemBulkAction(this.selection, {
+      name: 'list.delete',
+      callback: () => {
+        [...this.selection.value].forEach((listItem) => {
+          this._collection.remove(this._collection.getByKey(listItem.name));
+        });
+      },
+    });
+    this._destroyBulkDelete = destroy;
+    this.addActions([
+      {
+        action,
+        owner: this._owner,
+        weight: 100,
+      },
+    ]);
+  }
+
+  /**
+   * @private
+   */
+  _removeBulkDeleteAction() {
+    this._destroyBulkDelete();
+    const action = this._actions.value.find(
+      (a) => a.action.name === 'list.delete',
+    );
+    if (action) {
+      this.removeActions([action]);
+    }
+  }
+
+  /**
+   * uses the itemMappings to transform the given Item to an CollectionComponentListItem usable in the VcsList
    * @param {T} item
-   * @returns {import("@vcmap/ui").VcsListItem & { destroy: (function():void)|undefined }}
+   * @returns {CollectionComponentListItem}
    * @template T
    * @private
    */
@@ -219,9 +316,21 @@ class CollectionComponent {
       disabled: item?.properties?.disabled,
       tooltip: item?.properties?.tooltip,
       icon: item?.properties?.icon,
-      hasUpdate: item?.properties?.hasUpdate,
+      hasUpdate: false,
+      rename: false,
       actions: [],
+      clickedCallbacks: [],
+      destroy: undefined,
+      destroyFunctions: [],
     };
+    if (this.renamable.value) {
+      listItem.actions.push(createListItemRenameAction(listItem));
+      listItem.titleChanged = (newTitle) =>
+        titleChanged(item, listItem, newTitle);
+    }
+    if (this.removable.value) {
+      listItem.actions.push(createListItemDeleteAction(this._collection, item));
+    }
     this._itemMappings.forEach((itemMapping) => {
       if (
         itemMapping.predicate === undefined ||
@@ -230,16 +339,18 @@ class CollectionComponent {
         itemMapping.mappingFunction(item, this, listItem);
       }
     });
-    listItem.actions = listItem.actions.filter((action) => {
-      return validateAction(action);
-    });
+    listItem.actions = listItem.actions
+      .filter((action) => {
+        return validateAction(action);
+      })
+      .sort((a, b) => sortByWeight(a.weight, b.weight));
     return listItem;
   }
 
   /**
    * Inserts the listItem into the list items array at the correct relative position in respect to the position of the listItem
    * in the collection
-   * @param {import("@vcmap/ui").VcsListItem} listItem
+   * @param {CollectionComponentListItem} listItem
    * @private
    */
   _insertListItem(listItem) {
@@ -266,7 +377,7 @@ class CollectionComponent {
   }
 
   /**
-   * synchronizes the category items with the internal items list.
+   * synchronizes the collection items with the internal items list.
    * @param {T} item
    * @template T
    * @private
@@ -282,6 +393,31 @@ class CollectionComponent {
     }
   }
 
+  /**
+   * synchronizes the collection items with the internal items list by preserving previous selection
+   * @param {import("@vcmap/core").ReplacedEvent<T>} replaced
+   * @private
+   */
+  _handleItemReplaced(replaced) {
+    const selectedIdx = this.selection.value.findIndex(
+      (l) => l.name === replaced.old[this.collection.uniqueKey],
+    );
+    this._handleItemRemoved(replaced.old);
+    if (selectedIdx > -1) {
+      const addedListener = this._collection.added.addEventListener((added) => {
+        if (added === replaced.new) {
+          const newListItem = this.items.value.find(
+            (l) => l.name === added[this.collection.uniqueKey],
+          );
+          if (newListItem) {
+            this.selection.value.splice(selectedIdx, 0, newListItem);
+          }
+          addedListener();
+        }
+      });
+    }
+  }
+
   /**
    * synchronizes the order of the list items with respect to the order of the items in the collection.
    * removes and reinserts the moved item.
@@ -318,16 +454,28 @@ class CollectionComponent {
     });
     if (index > -1) {
       const listItem = this._listItems.value[index];
-      if (listItem.destroy) {
-        listItem.destroy();
+      const selectionIdx = this.selection.value.indexOf(listItem);
+      if (selectionIdx > -1) {
+        this.selection.value.splice(selectionIdx, 1);
       }
+      destroyListItem(this._listItems.value[index]);
       this._listItems.value.splice(index, 1);
     }
   }
 
+  /**
+   * @param {T} item
+   * @template T
+   * @returns {CollectionComponentListItem|undefined}
+   */
+  getListItemForItem(item) {
+    const itemKey = item[this._collection.uniqueKey];
+    return this.items.value.find((i) => i.name === itemKey);
+  }
+
   /**
    * recreates the items array with the new Mapping Function
-   * @param {ItemMapping} itemMapping
+   * @param {import("./collectionManager.js").ItemMapping<T>} itemMapping
    */
   addItemMapping(itemMapping) {
     if (
@@ -345,7 +493,7 @@ class CollectionComponent {
 
   /**
    * recreates the items array with the new Mapping Function
-   * @param {ItemMapping} itemMapping
+   * @param {import("./collectionManager.js").ItemMapping<T>} itemMapping
    */
   removeItemMapping(itemMapping) {
     const index = this._itemMappings.findIndex(({ mappingFunction, owner }) => {
@@ -362,7 +510,7 @@ class CollectionComponent {
 
   /**
    * recreates the items array with the new Filter Function
-   * @param {ItemFilter} itemFilter
+   * @param {import("./collectionManager.js").ItemFilter<T>} itemFilter
    */
   addItemFilter(itemFilter) {
     if (
@@ -380,7 +528,7 @@ class CollectionComponent {
 
   /**
    * recreates the items array with the new Filter Function
-   * @param {ItemFilter} itemFilter
+   * @param {import("./collectionManager.js").ItemFilter<T>} itemFilter
    */
   removeItemFilter(itemFilter) {
     const index = this._itemFilters.findIndex(({ filterFunction, owner }) => {
@@ -396,7 +544,7 @@ class CollectionComponent {
   }
 
   /**
-   * @param {Array<OwnedAction>} ownedActions
+   * @param {Array<import("./collectionManager.js").OwnedAction>} ownedActions
    */
   addActions(ownedActions) {
     const actions = [...this._actions.value, ...ownedActions];
@@ -404,11 +552,14 @@ class CollectionComponent {
       .filter((item, pos, self) => {
         return self.indexOf(item) === pos;
       })
-      .sort(sortByWeight);
+      .sort(
+        (a, b) =>
+          sortByWeight(a.weight, b.weight) || sortByOwner(a.owner, b.owner),
+      );
   }
 
   /**
-   * @param {Array<OwnedAction>} ownedActions
+   * @param {Array<import("./collectionManager.js").OwnedAction>} ownedActions
    */
   removeActions(ownedActions) {
     this._actions.value = this._actions.value.filter((ownedAction) => {
@@ -446,7 +597,7 @@ class CollectionComponent {
    * re-adding them from the collection applying current filter and mapping functions
    */
   reset() {
-    this._listItems.value.forEach((i) => i.destroy?.());
+    this._listItems.value.forEach(destroyListItem);
     this._listItems.value = [];
     this.selection.value = [];
     [...this._collection]
@@ -461,10 +612,12 @@ class CollectionComponent {
 
   destroy() {
     this._listeners.forEach((cb) => cb());
-    this._listItems.value.forEach((i) => i.destroy?.());
+    this._destroyBulkDelete();
+    this._resetWatchers.forEach((cb) => cb());
+    this._listItems.value.forEach(destroyListItem);
     this._listItems.value = [];
     this.selection.value = [];
   }
 }
 
-export default CollectionComponent;
+export default CollectionComponentClass;

package/src/manager/collectionManager/collectionManager.d.ts

@@ -0,0 +1,200 @@
+export default CollectionManager;
+export type MappingFunction<T extends Object> = (arg0: T, arg1: import("./collectionComponentClass.js").default<T>, arg2: import("./collectionComponentClass.js").CollectionComponentListItem) => void;
+export type PredicateFunction<T extends Object> = (arg0: T, arg1: import("./collectionComponentClass.js").default<T>) => boolean;
+export type ItemMapping<T extends Object> = {
+    predicate?: PredicateFunction<T>;
+    mappingFunction: MappingFunction<T>;
+    owner: string | symbol;
+};
+export type ItemFilter<T extends Object> = {
+    filterFunction: PredicateFunction<T>;
+    owner: string | symbol;
+};
+export type OwnedAction = {
+    action: import("../../actions/actionHelper.js").VcsAction;
+    /**
+     * Optional weight affecting the displaying order
+     */
+    weight?: number | undefined;
+    owner: string | symbol;
+};
+export type ICollectionManager = import("../../vcsUiApp.js").VcsComponentManager<CollectionComponentClass<any>, import("./collectionComponentClass.js").CollectionComponentClassOptions<Object>>;
+/**
+ * @typedef {function(T, import("./collectionComponentClass.js").default<T>, import("./collectionComponentClass.js").CollectionComponentListItem): void} MappingFunction
+ * @template {Object} T
+ */
+/**
+ * @typedef {function(T, import("./collectionComponentClass.js").default<T>): boolean} PredicateFunction
+ * @template {Object} T
+ */
+/**
+ * @typedef {{
+ *   predicate?: PredicateFunction<T>,
+ *   mappingFunction: MappingFunction<T>,
+ *   owner: string | symbol,
+ * }} ItemMapping
+ * @template {Object} T
+ */
+/**
+ * @typedef {{
+ *   filterFunction: PredicateFunction<T>,
+ *   owner: string | symbol
+ * }} ItemFilter
+ * @template {Object} T
+ */
+/**
+ * @typedef {Object} OwnedAction
+ * @property {import("../../actions/actionHelper.js").VcsAction} action
+ * @property {number} [weight=0] Optional weight affecting the displaying order
+ * @property {string | symbol} owner
+ */
+/**
+ * @typedef {import("../../vcsUiApp.js").VcsComponentManager<CollectionComponentClass, import("./collectionComponentClass.js").CollectionComponentClassOptions<Object>>} ICollectionManager
+ */
+/**
+ * Manages a list of collections as collectionComponents.
+ * Sets the correct mapping/filter functions and actions on the collectionComponent
+ * Provides an API to add/remove collectionsComponents.
+ * @implements {ICollectionManager}
+ */
+declare class CollectionManager implements ICollectionManager {
+    /**
+     * @type {VcsEvent<CollectionComponentClass<Object>>}
+     */
+    added: VcsEvent<CollectionComponentClass<Object>>;
+    /**
+     * @type {VcsEvent<CollectionComponentClass<Object>>}
+     */
+    removed: VcsEvent<CollectionComponentClass<Object>>;
+    /**
+     * @type {Array<string>}
+     */
+    componentIds: Array<string>;
+    /**
+     * @type {Map<string, CollectionComponentClass<Object>>}
+     * @private
+     */
+    private _collectionComponents;
+    /**
+     * @type {Array<ItemMapping & { collectionComponentIds:Array<string> }>}
+     * @private
+     */
+    private _itemMappings;
+    /**
+     * @type {Array<ItemFilter & { collectionComponentIds:Array<string> }>}
+     * @private
+     */
+    private _itemFilters;
+    /**
+     * @type {Array<{actions:Array<import("../../actions/actionHelper.js").VcsAction>,owner:string|symbol,collectionComponentIds:Array<string>}>}
+     * @private
+     */
+    private _actions;
+    /**
+     * @param {string} id
+     * @returns {CollectionComponentClass<Object>|undefined}
+     */
+    get(id: string): CollectionComponentClass<Object> | undefined;
+    /**
+     * @param {string} id
+     * @returns {boolean}
+     */
+    has(id: string): boolean;
+    /**
+     * @param {import("@vcmap/core").Collection<Object>} collection
+     * @returns {boolean}
+     */
+    hasCollection(collection: import("@vcmap/core").Collection<Object>): boolean;
+    /**
+     * gets all collection components corresponding to provided collection
+     * @param {import("@vcmap/core").Collection<T>} collection
+     * @returns {CollectionComponentClass<T>[]}
+     * @template {Object|import("@vcmap/core").VcsObject} T
+     */
+    getCollection<T extends Object | import("@vcmap/core/dist/src/vcsObject.js").default>(collection: Collection<T>): CollectionComponentClass<T>[];
+    /**
+     * adds a collectionComponent
+     * @param {import("./collectionComponentClass.js").CollectionComponentClassOptions<T>} collectionComponentOptions
+     * @param {string|symbol} owner
+     * @returns {CollectionComponentClass<T>}
+     * @template {Object|import("@vcmap/core").VcsObject} T
+     */
+    add<T_1 extends Object | import("@vcmap/core/dist/src/vcsObject.js").default>(collectionComponentOptions: import("./collectionComponentClass.js").CollectionComponentClassOptions<T_1>, owner: string | symbol): CollectionComponentClass<T_1>;
+    /**
+     * removes a CollectionComponentClass, Component will not be rendered anymore and will be destroyed. Add CollectionComponentClass again
+     * to show the component again
+     * @param {string} id
+     */
+    remove(id: string): void;
+    /**
+     * Gets affected ids for adding mapping and filter functions or actions.
+     * If no ids are provided, ids of all managed collectionComponents are returned.
+     * @param {Array<string>} [collectionComponentIds]
+     * @returns {string[]}
+     * @private
+     */
+    private _getAffectedIds;
+    /**
+     * adds MappingFunction to the collectionManager. For the given collectionComponents each Item will be transformed by the
+     * mappingFunction if the predicate returns true.
+     * @param {PredicateFunction<T>} predicate
+     * @param {MappingFunction<T>} mappingFunction
+     * @param {string | symbol} owner
+     * @param {Array<string>} [collectionComponentIds] list of collectionComponents this mappingFunction should be used on. If empty, mappingFunction is applied to all managed collectionComponents.
+     * @template {Object} T
+     */
+    addMappingFunction<T_2 extends Object>(predicate: PredicateFunction<T_2>, mappingFunction: MappingFunction<T_2>, owner: string | symbol, collectionComponentIds?: string[] | undefined): void;
+    /**
+     * removes the given mappingFunction
+     * @param {MappingFunction<T>} mappingFunction
+     * @param {string | symbol} owner
+     * @template {Object} T
+     */
+    removeMappingFunction<T_3 extends Object>(mappingFunction: MappingFunction<T_3>, owner: string | symbol): void;
+    /**
+     * @param {PredicateFunction<T>} filterFunction
+     * @param {string | symbol} owner
+     * @param {Array<string>} [collectionComponentIds] list of collectionComponents this filterFunction should be used on. If empty, filterFunction is applied to all managed collectionComponents.
+     * @template {Object} T
+     */
+    addFilterFunction<T_4 extends Object>(filterFunction: PredicateFunction<T_4>, owner: string | symbol, collectionComponentIds?: string[] | undefined): void;
+    /**
+     * removes the given filterFunction
+     * @param {PredicateFunction<T>} filterFunction
+     * @param {string | symbol} owner
+     * @template {Object} T
+     */
+    removeFilterFunction<T_5 extends Object>(filterFunction: PredicateFunction<T_5>, owner: string | symbol): void;
+    /**
+     * add multiple actions owned by the same owner
+     * @param {Array<import("../../actions/actionHelper.js").VcsAction>} actions
+     * @param {string | symbol} owner
+     * @param {Array<string>} [collectionComponentIds] list of collectionComponents this mappingFunction should be used on. If empty, actions are applied to all managed collectionComponents.
+     */
+    addActions(actions: Array<import("../../actions/actionHelper.js").VcsAction>, owner: string | symbol, collectionComponentIds?: string[] | undefined): void;
+    /**
+     * @param {Array<import("../../actions/actionHelper.js").VcsAction>} actions
+     * @param {string | symbol} owner
+     */
+    removeActions(actions: Array<import("../../actions/actionHelper.js").VcsAction>, owner: string | symbol): void;
+    /**
+     * removes managed collection components or actions and mapping/ filter functions belonging to the given owner.
+     * @param {string | symbol} owner
+     */
+    removeOwner(owner: string | symbol): void;
+    /**
+     * Resets all collectionComponents
+     */
+    reset(): void;
+    /**
+     * Clears the manager of all added categories and item mappings
+     */
+    clear(): void;
+    /**
+     * destroys the categoryManager, removes all Listeners and clears all Managed Categories
+     */
+    destroy(): void;
+}
+import CollectionComponentClass from './collectionComponentClass.js';
+import { VcsEvent } from '@vcmap/core';
+import { Collection } from '@vcmap/core';