@vcmap/ui 6.1.0-rc.1 → 6.1.0-rc.3

package/src/components/lists/listHelper.js

@@ -0,0 +1,348 @@
+import { computed, isReactive, reactive, ref, shallowRef, watch } from 'vue';
+
+/**
+ * @param {import("vue").Ref<import("./VcsListItemComponent.vue").VcsListItem[]>} items
+ * @param {import("vue").ShallowRef<import("./VcsListItemComponent.vue").VcsListItem[]>} selected
+ * @param {(event: 'update:modelValue', value: import("./VcsListItemComponent.vue").VcsListItem[]) => void} emit
+ * @returns {Array<import("../../actions/actionHelper.js").VcsAction>}
+ */
+export function createSelectionActions(items, selected, emit) {
+  const selectAllAction = reactive({
+    name: 'list.selectAll',
+    tooltip: 'list.selectAll',
+    disabled: computed(() => items.value.length - selected.value.length < 1),
+    callback() {
+      const currentSelection = [...selected.value];
+      selected.value = items.value.filter((item) => !item.disabled);
+
+      selected.value.forEach((item) => {
+        if (item.selectionChanged && !currentSelection.includes(item)) {
+          item.selectionChanged(true);
+        }
+      });
+      emit('update:modelValue', selected.value);
+    },
+  });
+
+  const clearSelectionAction = reactive({
+    name: 'list.clearSelection',
+    tooltip: 'list.clearSelection',
+    disabled: computed(() => selected.value.length < 1),
+    callback() {
+      [...selected.value].forEach((item) => {
+        if (item.selectionChanged) {
+          item.selectionChanged(false);
+        }
+      });
+      selected.value = [];
+      emit('update:modelValue', selected.value);
+    },
+  });
+
+  return [selectAllAction, clearSelectionAction];
+}
+
+/**
+ * @typedef {Object & {
+ * selectable?: boolean,
+ * singleSelect?: boolean,
+ * selectFunction?: (item: import("vue").UnwrapNestedRefs<import("./VcsListItemComponent.vue").VcsListItem>, event: PointerEvent) => void,
+ * modelValue?: Array<import("./VcsListItemComponent.vue").VcsListItem> }
+ * } SelectableListProps
+ * @property {boolean?} selectable
+ * @property {boolean?} singleSelect
+ * @property {(item: import("vue").UnwrapNestedRefs<import("./VcsListItemComponent.vue").VcsListItem>, event: PointerEvent) => void} selectFunction
+ * @property {Array<import("./VcsListItemComponent.vue").VcsListItem>?} modelValue
+ */
+
+/**
+ * @typedef {{
+ *   selected: import("vue").ShallowRef<Array<import("./VcsListItemComponent.vue").VcsListItem>>,
+ *   select: (item: import("vue").UnwrapNestedRefs<import("./VcsListItemComponent.vue").VcsListItem>, event: PointerEvent) => void,
+ *   selectionActions:Array<import("../../actions/actionHelper.js").VcsAction>
+ * }} SelectableListSetup
+ */
+
+/**
+ * Function setting up selection logic for lists. Use only in setup function of components!
+ * This requires VcsListItems with unique keys (name property).
+ * @param {Object & SelectableListProps} props
+ * @param {import("vue").ComputedRef<Array<import("./VcsListItemComponent.vue").VcsListItem>>} renderingItems
+ * @param {(event: 'update:modelValue', value: import("./VcsListItemComponent.vue").VcsListItem[]) => void} emit
+ * @returns {SelectableListSetup}
+ */
+export function setupSelectableList(props, renderingItems, emit) {
+  /** @type {import("vue").ShallowRef<Array<import("./VcsListItemComponent.vue").VcsListItem>>} */
+  const selected = shallowRef([]);
+
+  watch(
+    props,
+    () => {
+      if (selected.value !== props.modelValue) {
+        selected.value = props.modelValue;
+      }
+      if (props.singleSelect && selected.value.length > 1) {
+        selected.value
+          .filter((i, index) => index && i.selectionChanged)
+          .forEach((i) => i.selectionChanged(false));
+        selected.value = [selected.value[0]];
+        emit('update:modelValue', selected);
+      }
+      if (!props.selectable && selected.value.length > 0) {
+        selected.value
+          .filter((i) => i.selectionChanged)
+          .forEach((i) => i.selectionChanged(false));
+        selected.value = [];
+        emit('update:modelValue', selected);
+      }
+    },
+    { immediate: true, deep: false },
+  );
+
+  const selectionActions = createSelectionActions(
+    renderingItems,
+    selected,
+    emit,
+  );
+
+  let firstSelected;
+
+  return {
+    selected,
+    select:
+      props.selectFunction ||
+      ((item, event) => {
+        if (!props.selectable || item.disabled) {
+          return;
+        }
+        if (!isReactive(item)) {
+          throw new Error('Trying to select an unreactive item');
+        }
+        if (Array.isArray(item.clickedCallbacks)) {
+          item.clickedCallbacks.forEach((cb) => cb(event));
+        }
+        if (props.singleSelect) {
+          if (selected.value[0] === item) {
+            item.selectionChanged?.(false);
+            selected.value = [];
+            firstSelected = null;
+          } else {
+            selected.value[0]?.selectionChanged?.(false);
+            item.selectionChanged?.(true);
+            selected.value = [item];
+            firstSelected = item;
+          }
+        } else if (event.shiftKey) {
+          let firstIndex = 0;
+          if (firstSelected) {
+            firstIndex = renderingItems.value.indexOf(firstSelected);
+          }
+          const currentIndex = renderingItems.value.indexOf(item);
+          if (firstIndex > -1 && currentIndex > -1) {
+            const currentSelection = [...selected.value];
+            selected.value = renderingItems.value.slice(
+              Math.min(firstIndex, currentIndex),
+              Math.max(firstIndex, currentIndex) + 1,
+            );
+            currentSelection.forEach((oldItem) => {
+              if (
+                oldItem.selectionChanged &&
+                !selected.value.includes(oldItem)
+              ) {
+                oldItem.selectionChanged(false);
+              }
+            });
+            selected.value.forEach((newItem) => {
+              if (
+                newItem.selectionChanged &&
+                !currentSelection.includes(newItem)
+              ) {
+                newItem.selectionChanged(true);
+              }
+            });
+          } else {
+            selected.value
+              .filter((i) => i !== item && i.selectionChanged)
+              .forEach((i) => i.selectionChanged(false));
+            selected.value = [];
+            firstSelected = null;
+          }
+        } else if (selected.value.includes(item)) {
+          if (event.ctrlKey) {
+            item.selectionChanged?.(false);
+            selected.value = selected.value.filter((i) => i !== item);
+          } else if (selected.value.length > 1) {
+            selected.value
+              .filter((i) => i !== item && i.selectionChanged)
+              .forEach((i) => {
+                i.selectionChanged(false);
+              });
+            selected.value = [item];
+            firstSelected = item;
+          } else {
+            item.selectionChanged?.(false);
+            selected.value = [];
+            firstSelected = null;
+          }
+        } else if (event.ctrlKey) {
+          item.selectionChanged?.(true);
+          selected.value = [...selected.value, item];
+          if (selected.value.length === 1) {
+            firstSelected = item;
+          }
+        } else {
+          selected.value
+            .filter((i) => i !== item && i.selectionChanged)
+            .forEach((i) => i.selectionChanged(false));
+          item.selectionChanged?.(true);
+          selected.value = [item];
+          firstSelected = item;
+        }
+
+        emit('update:modelValue', selected.value);
+      }),
+    selectionActions,
+  };
+}
+
+/**
+ * @typedef {{
+ *   hovering: import("vue").Ref<number|undefined>,
+ *   dragging: import("vue").Ref<number|undefined>,
+ *   isDraggable: import("vue").ComputedRef<boolean>,
+ *   borderBottom: (index: number) => boolean,
+ *   borderTop: (index: number) => boolean,
+ *   dragStart: (
+ *     e: MouseEvent,
+ *     item: import('./VcsListItemComponent.vue').VcsListItem,
+ *     index: number,
+ *   ) => void;
+ *   dragOver: (e: MouseEvent, index: number) => void;
+ *   dragLeave: (e: MouseEvent) => void;
+ *   dragEnd: (e: MouseEvent) => void;
+ *   drop: (e: MouseEvent, targetIndex: number) => void;
+ * }} DraggableListSetup
+ */
+
+/**
+ * Function setting up drag logic for lists. Use only in setup function of components!
+ * This requires VcsListItems with unique keys (name property).
+ * @param {Object & { draggable: boolean }} props
+ * @param {import("vue").Ref<string>} query
+ * @param {(event: 'itemMoved', value: import("./VcsList.vue").ItemMovedEvent) => void} emit
+ * @returns {DraggableListSetup}
+ */
+export function setupDraggableList(props, query, emit) {
+  /** @type {import("vue").Ref<number|undefined>} */
+  const hovering = ref(undefined);
+  /** @type {import("vue").Ref<number|undefined>} */
+  const dragging = ref(undefined);
+
+  /**
+   * @param {number} index
+   * @returns {boolean}
+   */
+  function borderBottom(index) {
+    return (
+      dragging.value !== undefined &&
+      dragging.value < index &&
+      index === hovering.value
+    );
+  }
+
+  /**
+   * @param {number} index
+   * @returns {boolean}
+   */
+  function borderTop(index) {
+    return (
+      dragging.value !== undefined &&
+      dragging.value > index &&
+      index === hovering.value
+    );
+  }
+
+  /**
+   * @type {import("./VcsListItemComponent.vue").VcsListItem|null}
+   */
+  let draggedItem = null;
+
+  /**
+   * @type {import("vue").ComputedRef<boolean>}
+   */
+  const isDraggable = computed(() => {
+    return !query.value && props.draggable;
+  });
+
+  /**
+   * @param {MouseEvent} e
+   * @param {number} targetIndex
+   */
+  function drop(e, targetIndex) {
+    if (isDraggable.value) {
+      if (draggedItem !== null && targetIndex !== undefined) {
+        emit('itemMoved', { item: draggedItem, targetIndex });
+      }
+      draggedItem = null;
+      dragging.value = undefined;
+      hovering.value = undefined;
+    }
+  }
+
+  /**
+   * @param {MouseEvent} e
+   * @param {import("./VcsListItemComponent.vue").VcsListItem} item
+   * @param {number} index
+   */
+  function dragStart(e, item, index) {
+    e.stopPropagation();
+    if (isDraggable.value) {
+      dragging.value = index;
+      draggedItem = item;
+      e.dataTransfer.effectAllowed = 'move';
+    }
+  }
+
+  /**
+   * @param {MouseEvent} e
+   * @param {number} index
+   */
+  function dragOver(e, index) {
+    e.stopPropagation();
+    e.preventDefault();
+    if (isDraggable.value) {
+      hovering.value = index;
+    }
+  }
+
+  /**
+   * @param {MouseEvent} e
+   */
+  function dragLeave(e) {
+    e.stopPropagation();
+    e.preventDefault();
+    hovering.value = undefined;
+  }
+
+  /**
+   * @param {MouseEvent} e
+   */
+  function dragEnd(e) {
+    e.stopPropagation();
+    dragging.value = undefined;
+    hovering.value = undefined;
+  }
+
+  return {
+    hovering,
+    dragging,
+    isDraggable,
+    borderBottom,
+    borderTop,
+    dragStart,
+    dragOver,
+    dragLeave,
+    dragEnd,
+    drop,
+  };
+}

package/src/components/section/VcsFormSection.vue

@@ -64,6 +64,7 @@
    * @vue-prop {Array<VcsAction>}    headerActions - Icons to be displayed on the right side
    * @vue-prop {number} [actionButtonListOverflowCount] - overflow count to use for action lists in the title and items
    * @vue-prop {string} [helpText] - Optional help text. Must be plain string. Use 'help' slot for html based help texts. Help slot has precedence over helpText prop.
+   * @vue-prop {boolean} [startHelpOpen=false] - If help text starts open.
    * @vue-computed {Array<VcsAction>} actions - Returns header actions extended by a help action, if help prop is passed or help slot is used.
    */
   export default {
@@ -104,6 +105,10 @@
         type: String,
         default: undefined,
       },
+      startHelpOpen: {
+        type: Boolean,
+        default: false,
+      },
     },
     setup(props, { slots }) {
       const open = ref(props.startOpen);
@@ -116,7 +121,7 @@
       const helpAction = reactive({
         name: 'help',
         title: 'components.vcsFormSection.help',
-        active: false,
+        active: props.startHelpOpen,
         icon: 'mdi-help-circle',
         callback() {
           this.active = !this.active;
@@ -128,7 +133,7 @@
        */
       const actions = computed(() => {
         if (props.helpText || (slots.help && slots.help().length > 0)) {
-          return [helpAction, ...props.headerActions];
+          return [...props.headerActions, helpAction];
         }
         return props.headerActions;
       });

package/src/components/section/VcsFormSection.vue.d.ts

@@ -28,6 +28,10 @@ declare const _default: import("vue").DefineComponent<{
         type: StringConstructor;
         default: undefined;
     };
+    startHelpOpen: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
 }, {
     open: import("vue").Ref<boolean>;
     showContent: import("vue").ComputedRef<boolean>;
@@ -64,6 +68,10 @@ declare const _default: import("vue").DefineComponent<{
         type: StringConstructor;
         default: undefined;
     };
+    startHelpOpen: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
 }>>, {
     disabled: boolean;
     headerActions: unknown[];
@@ -72,5 +80,6 @@ declare const _default: import("vue").DefineComponent<{
     helpText: string;
     expandable: boolean;
     startOpen: boolean;
+    startHelpOpen: boolean;
 }, {}>;
 export default _default;

package/src/components/tables/VcsDataTable.vue

@@ -168,6 +168,7 @@
    * @vue-prop {boolean} [showSearchbar=true] - whether to show searchbar
    * @vue-prop {string} [searchbarPlaceholder] - placeholder for searchbar
    * @vue-prop {string} [itemSelectable='isSelectable'] - The property on each item that is used to determine if it is selectable or not. Non-selectable items are automatically disabled.
+   * @vue-prop {function(any, string|undefined, TableItem):boolean} [customFilter] - a function to customize filtering when searching. The first parameter represents the item values, with the function called for each of them. The second is the search term. The third is the complete item.
    * @vue-event {UpdateItemsEvent} update:items - Emits when one of the options properties is updated or on search input. Can be used to update items via API call to a server.
    * @vue-computed {Array<TableItem>} filteredItems - array of items with search filter applied on. If search string is empty, same as items array.
    * @vue-computed {Array<import("vuetify").DataTableHeader>} translatedHeaders - array of translated header items.
@@ -232,6 +233,10 @@
         type: String,
         default: 'isSelectable',
       },
+      customFilter: {
+        type: Function,
+        default: undefined,
+      },
     },
     setup(props, { attrs, emit, slots }) {
       const vm = getCurrentInstance().proxy;
@@ -272,6 +277,9 @@
        * @returns {boolean}
        */
       const handleFilter = (value, filter, item) => {
+        if (props.customFilter) {
+          return props.customFilter(value, filter, item.raw);
+        }
         return handleFilterInternal(value, filter, item.raw);
       };
 
@@ -300,9 +308,12 @@
        * @type {ComputedRef<Array<Object>>}
        */
       const filteredItems = computed(() =>
-        props.items.filter((item) =>
-          handleFilterInternal(item.value, search.value, item),
-        ),
+        props.items.filter((item) => {
+          if (props.customFilter) {
+            return props.customFilter(item.value, search.value, item);
+          }
+          return handleFilterInternal(item.value, search.value, item);
+        }),
       );
       const numberOfItems = computed(() => {
         if (props.serverItemsLength > -1) {

package/src/components/tables/VcsDataTable.vue.d.ts

@@ -40,6 +40,10 @@ declare const _default: import("vue").DefineComponent<{
         type: StringConstructor;
         default: string;
     };
+    customFilter: {
+        type: FunctionConstructor;
+        default: undefined;
+    };
 }, {
     hovering: import("vue").Ref<null>;
     search: Ref<UnwrapRef<string>>;
@@ -102,8 +106,13 @@ declare const _default: import("vue").DefineComponent<{
         type: StringConstructor;
         default: string;
     };
+    customFilter: {
+        type: FunctionConstructor;
+        default: undefined;
+    };
 }>>, {
     items: unknown[];
+    customFilter: Function;
     showSearchbar: boolean;
     searchbarPlaceholder: string;
     headers: unknown[];

package/src/components/vector-properties/VcsVectorPropertiesComponent.vue.d.ts

@@ -218,7 +218,7 @@ declare const _default: import("vue").DefineComponent<{
         getPrimitiveOptions: (feature: import("ol/Feature.js", { with: { "resolution-mode": "import" } }).default<import("ol/geom.js", { with: { "resolution-mode": "import" } }).Geometry>) => import("@vcmap/core", { with: { "resolution-mode": "import" } }).VectorPropertiesPrimitiveOptions<import("@vcmap/core", { with: { "resolution-mode": "import" } }).PrimitiveOptionsType> | undefined;
         getPrimitive: (feature: import("ol/Feature.js", { with: { "resolution-mode": "import" } }).default<import("ol/geom.js", { with: { "resolution-mode": "import" } }).Geometry>) => import("@vcmap/core", { with: { "resolution-mode": "import" } }).VectorPropertiesPrimitive | null;
         getModel: (feature: import("ol/Feature.js", { with: { "resolution-mode": "import" } }).default<import("ol/geom.js", { with: { "resolution-mode": "import" } }).Geometry>) => import("@vcmap/core", { with: { "resolution-mode": "import" } }).VectorPropertiesModelOptions | null;
-        renderAs: (feature: import("ol/Feature.js", { with: { "resolution-mode": "import" } }).default<import("ol/geom.js", { with: { "resolution-mode": "import" } }).Geometry>) => "geometry" | "model" | "primitive";
+        renderAs: (feature: import("ol/Feature.js", { with: { "resolution-mode": "import" } }).default<import("ol/geom.js", { with: { "resolution-mode": "import" } }).Geometry>) => "geometry" | "primitive" | "model";
         setVcsMeta: (vcsMeta: import("@vcmap/core", { with: { "resolution-mode": "import" } }).VcsMeta) => void;
         setValues: (options: import("@vcmap/core", { with: { "resolution-mode": "import" } }).VectorPropertiesOptions) => void;
         getValues: () => import("@vcmap/core", { with: { "resolution-mode": "import" } }).VectorPropertiesOptions;

package/src/contentTree/LayerTree.vue

@@ -20,7 +20,8 @@
   import { VSheet } from 'vuetify/components';
   import VcsTreeview from '../components/lists/VcsTreeview.vue';
 
-  const openStateMapSymbol = Symbol('openStateMap');
+  /** The open state Symbol of the ContentTree */
+  export const openStateMapSymbol = Symbol('openStateMap');
   /**
    * @description
    * Implements Treeview and shows content tree

package/src/contentTree/LayerTree.vue.d.ts

@@ -1,3 +1,5 @@
+/** The open state Symbol of the ContentTree */
+export const openStateMapSymbol: unique symbol;
 declare const _default: import("vue").DefineComponent<{
     windowState: {
         type: ObjectConstructor;

package/src/contentTree/contentTreeCollection.d.ts

@@ -3,6 +3,7 @@
  * @returns {import("@vcmap/core").OverrideCollection<ContentTreeItem, ContentTreeCollection>}
  */
 export function createContentTreeCollection(app: import("@src/vcsUiApp.js").default): import("@vcmap/core").OverrideCollection<ContentTreeItem, ContentTreeCollection>;
+export const defaultContentTreeComponentId: "Content";
 export default ContentTreeCollection;
 export type ParentTreeViewItem = {
     treeViewItem?: import("./contentTreeItem.js").TreeViewItem | undefined;

package/src/contentTree/contentTreeCollection.js

@@ -20,6 +20,8 @@ import { ButtonLocation } from '../manager/navbarManager.js';
 const subTreeOpenStateSymbol = Symbol('SubTreeOpenState');
 const subTreeItemWeight = Symbol('SubTreeItemWeight');
 
+export const defaultContentTreeComponentId = 'Content';
+
 /**
  * @typedef {Object} ParentTreeViewItem
  * @property {import("./contentTreeItem.js").TreeViewItem} [treeViewItem]
@@ -77,7 +79,9 @@ class ContentTreeCollection extends IndexedCollection {
         contentTreeActiveOnStartup?.value &&
         contentTreeActiveOnStartup[moduleIdSymbol] !== this._app.dynamicModuleId
       ) {
-        const action = this._app.navbarManager.get('Content')?.action;
+        const action = this._app.navbarManager.get(
+          defaultContentTreeComponentId,
+        )?.action;
         if (action && !action.active) {
           action.callback();
         }
@@ -119,7 +123,7 @@ class ContentTreeCollection extends IndexedCollection {
      */
     this._defaultSubtreeItem = new SubContentTreeItem(
       {
-        name: 'Content',
+        name: defaultContentTreeComponentId,
         icon: '$vcsLayers',
         title: 'content.title',
         tooltip: 'content.title',
@@ -198,7 +202,7 @@ class ContentTreeCollection extends IndexedCollection {
       'contentTreeActiveOnStartup',
     );
     if (
-      id === 'Content' &&
+      id === defaultContentTreeComponentId &&
       contentTreeActiveOnStartup?.value &&
       contentTreeActiveOnStartup[moduleIdSymbol] !== this._app.dynamicModuleId
     ) {

package/src/contentTree/contentTreeItem.js

@@ -422,9 +422,11 @@ class ContentTreeItem {
       (a) => a[actionWeightSymbol] > weight,
     );
     if (insertIndex > -1) {
-      this._actions.value.splice(insertIndex, 0, action);
+      const newActions = [...this._actions.value];
+      newActions.splice(insertIndex, 0, action);
+      this._actions.value = newActions;
     } else {
-      this._actions.value.push(action);
+      this._actions.value = [...this._actions.value, action];
     }
   }
 

package/src/contentTree/groupContentTreeItem.js

@@ -33,11 +33,13 @@ class GroupContentTreeItem extends ContentTreeItem {
       () => {
         const children = this._children.value;
         this.visible = children.some((c) => c.visible);
-        if (children.every((c) => c.state === StateActionState.NONE)) {
+        if (
+          children.every((c) => c.state === StateActionState.NONE || !c.visible)
+        ) {
           this.state = StateActionState.NONE;
         } else {
           const childrenWithState = children.filter(
-            (c) => c.state !== StateActionState.NONE,
+            (c) => c.visible && c.state !== StateActionState.NONE,
           );
           if (
             childrenWithState.every((c) => c.state === StateActionState.ACTIVE)
@@ -54,7 +56,7 @@ class GroupContentTreeItem extends ContentTreeItem {
           }
         }
       },
-      { deep: true },
+      { deep: true, immediate: true },
     );
   }
 

package/src/featureInfo/ClusterFeatureComponent.vue

@@ -0,0 +1,58 @@
+<script setup>
+  import { ref, shallowRef, inject, onUnmounted } from 'vue';
+  import VcsGroupedList from '../components/lists/VcsGroupedList.vue';
+
+  const props = defineProps({
+    /** @type {import("../components/lists/VcsGroupedList.vue").VcsGroupedListItem} */
+    items: {
+      type: Array,
+      default: () => [],
+    },
+    /** @type {import("../components/lists/VcsGroupedList.vue").VcsListGroup} */
+    groups: {
+      type: Array,
+      default: () => [],
+    },
+  });
+
+  const app = inject('vcsApp');
+  const open = ref(true);
+  const selected = shallowRef([]);
+
+  const selectionListener = app.featureInfo.featureChanged.addEventListener(
+    (f) => {
+      if (f === null) {
+        selected.value = [];
+      } else {
+        const item = props.items.find((i) => i.name === f.getId());
+        if (item) {
+          selected.value = [item];
+        }
+      }
+    },
+  );
+
+  onUnmounted(() => {
+    selectionListener();
+  });
+</script>
+
+<template>
+  <div>
+    <template v-if="items.length > 0">
+      <vcs-grouped-list
+        v-if="open"
+        :items="items"
+        :groups="groups"
+        v-model="selected"
+        selectable
+        single-select
+        searchable
+        open-all
+      />
+    </template>
+    <p v-else>{{ $t('featureInfo.cluster.empty') }}</p>
+  </div>
+</template>
+
+<style scoped lang="scss"></style>

package/src/featureInfo/ClusterFeatureComponent.vue.d.ts

@@ -0,0 +1,6 @@
+declare const _default: import("vue").DefineComponent<{}, {
+    $props: {
+        readonly [x: string]: any;
+    };
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}, {}>;
+export default _default;

package/src/featureInfo/abstractFeatureInfoView.js

@@ -1,7 +1,6 @@
-import { VcsObject } from '@vcmap/core';
+import { renderTemplate, VcsObject } from '@vcmap/core';
 import { WindowSlot } from '../manager/window/windowManager.js';
 import { defaultTagOptions } from '../components/tables/VcsTable.vue';
-import { renderTemplate } from '../components/form-output/markdownHelper.js';
 
 /**
  * @typedef {Object} FeatureInfoProps