@vcmap/ui 6.3.10 → 7.0.0-rc.1

package/src/manager/contextMenu/ContextMenuComponent.vue.d.ts

@@ -2,17 +2,18 @@
  * @type {string}
  */
 export const contextMenuWindowId: string;
-declare const _default: import("vue").DefineComponent<{
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: import("vue", { with: { "resolution-mode": "import" } }).DefineComponent<{
     actions: {
         type: ArrayConstructor;
         required: true;
     };
 }, {
     close: () => void;
-}, any, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+}, any, {}, {}, import("vue", { with: { "resolution-mode": "import" } }).ComponentOptionsMixin, import("vue", { with: { "resolution-mode": "import" } }).ComponentOptionsMixin, {}, string, import("vue", { with: { "resolution-mode": "import" } }).PublicProps, Readonly<import("vue", { with: { "resolution-mode": "import" } }).ExtractPropTypes<{
     actions: {
         type: ArrayConstructor;
         required: true;
     };
 }>>, {}, {}>;
-export default _default;

package/src/manager/contextMenu/contextMenuManager.js

@@ -3,7 +3,7 @@ import { unByKey } from 'ol/Observable.js';
 import { check, oneOf } from '@vcsuite/check';
 import ContextMenuInteraction from './contextMenuInteraction.js';
 import { vcsAppSymbol } from '../../pluginHelper.js';
-import { validateAction } from '../../components/lists/VcsActionList.vue';
+import { validateAction } from '../../components/lists/VcsActionList.ts.vue';
 import { WindowSlot } from '../window/windowManager.js';
 import { getFittedWindowPositionOptionsFromMapEvent } from '../window/windowHelper.js';
 import ContextMenuComponent, {

package/src/manager/navbarManager.d.ts

@@ -5,7 +5,7 @@
  * @param {string[]} [order] order of owners to sort by
  * @returns {number}
  */
-export function sortByOwner(ownerA: string | symbol, ownerB: string | symbol, order?: string[] | undefined): number;
+export function sortByOwner(ownerA: string | symbol, ownerB: string | symbol, order?: string[]): number;
 /**
  * filters actions by button location and returns actions (optionally sorted)
  * @param {Array<NavbarButtonComponent>} buttonComponents
@@ -14,7 +14,7 @@ export function sortByOwner(ownerA: string | symbol, ownerB: string | symbol, or
  * @param {function(NavbarButtonComponent, NavbarButtonComponent):number} [compareFn=sortByOwner] Per default components are sorted by weight (highest first) and owner (app first, then plugins)
  * @returns {Array<import("../actions/actionHelper.js").VcsAction>}
  */
-export function getActionsByLocation(buttonComponents: Array<NavbarButtonComponent>, location: ButtonLocation, order?: string[] | undefined, compareFn?: ((arg0: NavbarButtonComponent, arg1: NavbarButtonComponent) => number) | undefined): Array<import("../actions/actionHelper.js").VcsAction>;
+export function getActionsByLocation(buttonComponents: Array<NavbarButtonComponent>, location: ButtonLocation, order?: string[], compareFn?: (arg0: NavbarButtonComponent, arg1: NavbarButtonComponent) => number): Array<import("../actions/actionHelper.js").VcsAction>;
 export const locationSymbol: unique symbol;
 export const deviceSymbol: unique symbol;
 /**
@@ -31,7 +31,7 @@ export namespace ButtonLocation {
 }
 export default NavbarManager;
 export type INavbarManager = import("../vcsUiApp.js").VcsComponentManager<NavbarButtonComponent, import("./buttonManager.js").ButtonComponentOptions>;
-export type Device = 'desktop' | 'tablet' | 'mobile';
+export type Device = "desktop" | "tablet" | "mobile";
 export type DeviceOptions = Partial<Record<Device, boolean>>;
 export type NavbarButtonComponent = import("./buttonManager.js").ButtonComponent & {
     [locationSymbol]: ButtonLocation;
@@ -68,7 +68,7 @@ declare class NavbarManager extends ButtonManager implements INavbarManager {
      * @returns {NavbarButtonComponent}
      */
     // @ts-ignore
-add(buttonComponentOptions: import("./buttonManager.js").ButtonComponentOptions, owner: string | symbol, location: ButtonLocation, device?: Partial<Record<Device, boolean>> | undefined): NavbarButtonComponent;
+add(buttonComponentOptions: import("./buttonManager.js").ButtonComponentOptions, owner: string | symbol, location: ButtonLocation, device?: DeviceOptions): NavbarButtonComponent;
     /**
      * @param {string} id
      * @returns {NavbarButtonComponent}
@@ -80,6 +80,6 @@ add(buttonComponentOptions: import("./buttonManager.js").ButtonComponentOptions,
      * @param {string} id
      * @param {boolean} [active]
      */
-    toggle(id: string, active?: boolean | undefined): void;
+    toggle(id: string, active?: boolean): void;
 }
 import ButtonManager from './buttonManager.js';

package/src/manager/panel/PanelComponent.vue.d.ts

@@ -1,15 +1,17 @@
-declare const _default: import("vue").DefineComponent<{
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: import("vue", { with: { "resolution-mode": "import" } }).DefineComponent<{
     panelState: {
         type: ObjectConstructor;
         required: true;
     };
 }, {
-    appIsDark: import("vue").ComputedRef<any>;
-    isLeft: import("vue").ComputedRef<boolean>;
-    isRight: import("vue").ComputedRef<boolean>;
-    isBottom: import("vue").ComputedRef<boolean>;
+    appIsDark: import("vue", { with: { "resolution-mode": "import" } }).ComputedRef<any>;
+    isLeft: import("vue", { with: { "resolution-mode": "import" } }).ComputedRef<boolean>;
+    isRight: import("vue", { with: { "resolution-mode": "import" } }).ComputedRef<boolean>;
+    isBottom: import("vue", { with: { "resolution-mode": "import" } }).ComputedRef<boolean>;
     startResize(e: any): void;
-}, any, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "resize"[], "resize", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+}, any, {}, {}, import("vue", { with: { "resolution-mode": "import" } }).ComponentOptionsMixin, import("vue", { with: { "resolution-mode": "import" } }).ComponentOptionsMixin, "resize"[], "resize", import("vue", { with: { "resolution-mode": "import" } }).PublicProps, Readonly<import("vue", { with: { "resolution-mode": "import" } }).ExtractPropTypes<{
     panelState: {
         type: ObjectConstructor;
         required: true;
@@ -17,4 +19,3 @@ declare const _default: import("vue").DefineComponent<{
 }>> & {
     onResize?: ((...args: any[]) => any) | undefined;
 }, {}, {}>;
-export default _default;

package/src/manager/panel/PanelManagerComponent.vue.d.ts

@@ -2,22 +2,24 @@
  * @returns {Partial<import("./panelManager.js").PanelComponent>}
  */
 export function createMainPanel(): Partial<import("./panelManager.js").PanelComponent>;
-declare const _default: import("vue").DefineComponent<{}, {
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: import("vue", { with: { "resolution-mode": "import" } }).DefineComponent<{}, {
     mainPanel: Partial<import("./panelManager.js", { with: { "resolution-mode": "import" } }).PanelComponent>;
     componentIds: PanelManager;
     getComponent: (id: any) => any;
-    getPosition: (panelComponent: import("vue").DefineComponent<{
+    getPosition: (panelComponent: import("vue", { with: { "resolution-mode": "import" } }).DefineComponent<{
         panelState: {
             type: ObjectConstructor;
             required: true;
         };
     }, {
-        appIsDark: import("vue").ComputedRef<any>;
-        isLeft: import("vue").ComputedRef<boolean>;
-        isRight: import("vue").ComputedRef<boolean>;
-        isBottom: import("vue").ComputedRef<boolean>;
+        appIsDark: import("vue", { with: { "resolution-mode": "import" } }).ComputedRef<any>;
+        isLeft: import("vue", { with: { "resolution-mode": "import" } }).ComputedRef<boolean>;
+        isRight: import("vue", { with: { "resolution-mode": "import" } }).ComputedRef<boolean>;
+        isBottom: import("vue", { with: { "resolution-mode": "import" } }).ComputedRef<boolean>;
         startResize(e: any): void;
-    }, any, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "resize"[], "resize", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    }, any, {}, {}, import("vue", { with: { "resolution-mode": "import" } }).ComponentOptionsMixin, import("vue", { with: { "resolution-mode": "import" } }).ComponentOptionsMixin, "resize"[], "resize", import("vue", { with: { "resolution-mode": "import" } }).PublicProps, Readonly<import("vue", { with: { "resolution-mode": "import" } }).ExtractPropTypes<{
         panelState: {
             type: ObjectConstructor;
             required: true;
@@ -28,12 +30,11 @@ declare const _default: import("vue").DefineComponent<{}, {
     getStyles: (id: string) => import("vue").ComputedRef<Object>;
     getState: (id: string) => PanelState;
     getProps: (id: string) => Object;
-    addMobileClass: import("vue").ComputedRef<any>;
-    panelFrameRef: import("vue").Ref<any>;
-    resizing: import("vue").Ref<undefined>;
-    resizeCursor: import("vue").ComputedRef<"default" | "n-resize" | "ew-resize">;
+    addMobileClass: import("vue", { with: { "resolution-mode": "import" } }).ComputedRef<any>;
+    panelFrameRef: import("vue", { with: { "resolution-mode": "import" } }).Ref<any>;
+    resizing: import("vue", { with: { "resolution-mode": "import" } }).Ref<undefined>;
+    resizeCursor: import("vue", { with: { "resolution-mode": "import" } }).ComputedRef<"default" | "n-resize" | "ew-resize">;
     setResizing: (id: any) => void;
-    resizingFunction: import("vue").Ref<() => void>;
+    resizingFunction: import("vue", { with: { "resolution-mode": "import" } }).Ref<() => void>;
     close: (id: any) => void;
-}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}, {}>;
-export default _default;
+}, {}, {}, {}, import("vue", { with: { "resolution-mode": "import" } }).ComponentOptionsMixin, import("vue", { with: { "resolution-mode": "import" } }).ComponentOptionsMixin, {}, string, import("vue", { with: { "resolution-mode": "import" } }).PublicProps, Readonly<import("vue", { with: { "resolution-mode": "import" } }).ExtractPropTypes<{}>>, {}, {}>;

package/src/manager/panel/panelManager.d.ts

@@ -81,33 +81,24 @@ export type DefaultPanelPositions = Partial<PanelPosition>;
  * @private
  */
 export const DefaultPanelPositions: {
-    [x: string]: {
+    [PanelLocation.LEFT]: {
         left: string;
         width: string;
         minWidth: string;
         height: string;
-        right?: undefined;
-        bottom?: undefined;
-        minHeight?: undefined;
-        maxHeight?: undefined;
-    } | {
+    };
+    [PanelLocation.RIGHT]: {
         right: string;
         width: string;
         minWidth: string;
         height: string;
-        left?: undefined;
-        bottom?: undefined;
-        minHeight?: undefined;
-        maxHeight?: undefined;
-    } | {
+    };
+    [PanelLocation.BOTTOM]: {
         bottom: string;
         width: string;
         height: string;
         minHeight: string;
         maxHeight: string;
-        left?: undefined;
-        minWidth?: undefined;
-        right?: undefined;
     };
 };
 export default PanelManager;

package/src/manager/panel/panelManager.js

@@ -244,6 +244,7 @@ class PanelManager {
     check(id, String);
     const panelComponent = this._panelComponents.get(id);
     if (panelComponent) {
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
       const { left, right, top, bottom, ...widthAndHeightOptions } =
         getPanelPosition(panelComponent);
       this._panelPositionsCache.set(panelComponent.id, {

package/src/manager/toolbox/GroupToolboxComponent.vue

@@ -59,7 +59,7 @@
   import { computed, ref } from 'vue';
   import { VMenu, VIcon, VToolbar, VToolbarItems } from 'vuetify/components';
   import { useDisplay } from 'vuetify';
-  import VcsToolButton from '../../components/buttons/VcsToolButton.vue';
+  import VcsToolButton from '../../components/buttons/VcsToolButton.ts.vue';
   import { getComponentsByOrder } from './toolboxManager.js';
   import { useFontSize } from '../../vuePlugins/vuetify.js';
 

package/src/manager/toolbox/GroupToolboxComponent.vue.d.ts

@@ -1,15 +1,17 @@
-declare const _default: import("vue").DefineComponent<{
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: import("vue", { with: { "resolution-mode": "import" } }).DefineComponent<{
     group: {
         type: ObjectConstructor;
         required: true;
     };
 }, {
-    open: import("vue").Ref<boolean>;
-    orderedButtons: import("vue").ComputedRef<(import("../buttonManager.js", { with: { "resolution-mode": "import" } }).ButtonComponent | import("./toolboxManager.js", { with: { "resolution-mode": "import" } }).ToolboxComponent)[]>;
-    hasActiveAction: import("vue").ComputedRef<boolean>;
-    toolboxHeight: import("vue").ComputedRef<number>;
-    xs: import("vue").Ref<boolean>;
-}, any, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("click" | "toggle")[], "click" | "toggle", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    open: import("vue", { with: { "resolution-mode": "import" } }).Ref<boolean>;
+    orderedButtons: import("vue", { with: { "resolution-mode": "import" } }).ComputedRef<(import("../buttonManager.js", { with: { "resolution-mode": "import" } }).ButtonComponent | import("./toolboxManager.js", { with: { "resolution-mode": "import" } }).ToolboxComponent)[]>;
+    hasActiveAction: import("vue", { with: { "resolution-mode": "import" } }).ComputedRef<boolean>;
+    toolboxHeight: import("vue", { with: { "resolution-mode": "import" } }).ComputedRef<number>;
+    xs: import("vue", { with: { "resolution-mode": "import" } }).Ref<boolean>;
+}, any, {}, {}, import("vue", { with: { "resolution-mode": "import" } }).ComponentOptionsMixin, import("vue", { with: { "resolution-mode": "import" } }).ComponentOptionsMixin, ("click" | "toggle")[], "click" | "toggle", import("vue", { with: { "resolution-mode": "import" } }).PublicProps, Readonly<import("vue", { with: { "resolution-mode": "import" } }).ExtractPropTypes<{
     group: {
         type: ObjectConstructor;
         required: true;
@@ -18,4 +20,3 @@ declare const _default: import("vue").DefineComponent<{
     onClick?: ((...args: any[]) => any) | undefined;
     onToggle?: ((...args: any[]) => any) | undefined;
 }, {}, {}>;
-export default _default;

package/src/manager/toolbox/SelectToolboxComponent.vue

@@ -74,7 +74,7 @@
   import { ref, computed } from 'vue';
   import { VMenu, VIcon, VToolbar, VToolbarItems } from 'vuetify/components';
   import { useDisplay } from 'vuetify';
-  import VcsToolButton from '../../components/buttons/VcsToolButton.vue';
+  import VcsToolButton from '../../components/buttons/VcsToolButton.ts.vue';
   import { useFontSize } from '../../vuePlugins/vuetify.js';
 
   /**

package/src/manager/toolbox/SelectToolboxComponent.vue.d.ts

@@ -1,13 +1,15 @@
-declare const _default: import("vue").DefineComponent<{
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: import("vue", { with: { "resolution-mode": "import" } }).DefineComponent<{
     group: {
         type: ObjectConstructor;
         required: true;
     };
 }, {
-    open: import("vue").Ref<boolean>;
-    toolboxHeight: import("vue").ComputedRef<number>;
-    xs: import("vue").Ref<boolean>;
-}, any, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("click" | "toggle")[], "click" | "toggle", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    open: import("vue", { with: { "resolution-mode": "import" } }).Ref<boolean>;
+    toolboxHeight: import("vue", { with: { "resolution-mode": "import" } }).ComputedRef<number>;
+    xs: import("vue", { with: { "resolution-mode": "import" } }).Ref<boolean>;
+}, any, {}, {}, import("vue", { with: { "resolution-mode": "import" } }).ComponentOptionsMixin, import("vue", { with: { "resolution-mode": "import" } }).ComponentOptionsMixin, ("click" | "toggle")[], "click" | "toggle", import("vue", { with: { "resolution-mode": "import" } }).PublicProps, Readonly<import("vue", { with: { "resolution-mode": "import" } }).ExtractPropTypes<{
     group: {
         type: ObjectConstructor;
         required: true;
@@ -16,4 +18,3 @@ declare const _default: import("vue").DefineComponent<{
     onClick?: ((...args: any[]) => any) | undefined;
     onToggle?: ((...args: any[]) => any) | undefined;
 }, {}, {}>;
-export default _default;

package/src/manager/toolbox/ToolboxManagerComponent.vue

@@ -67,7 +67,7 @@
   } from './toolboxManager.js';
   import ToolboxActionSelect from './SelectToolboxComponent.vue';
   import ToolboxActionGroup from './GroupToolboxComponent.vue';
-  import VcsToolButton from '../../components/buttons/VcsToolButton.vue';
+  import VcsToolButton from '../../components/buttons/VcsToolButton.ts.vue';
   import { vcsAppSymbol } from '../../pluginHelper.js';
   import { ButtonLocation, deviceSymbol } from '../navbarManager.js';
   import { useFontSize } from '../../vuePlugins/vuetify.js';

package/src/manager/toolbox/ToolboxManagerComponent.vue.d.ts

@@ -9,8 +9,19 @@
  * @property {function(number):void} [selectCb]
  */
 export const toolboxComponentId: "toolbox";
-declare const _default: import("vue").DefineComponent<{}, {
-    smAndUp: import("vue").Ref<boolean>;
+declare const _default: typeof __VLS_export;
+export default _default;
+export type ToolboxButtonGroup = {
+    id: string;
+    type: string;
+    icon: string;
+    title: string;
+    buttons: Array<import("../buttonManager.js").ButtonComponent>;
+    selected?: string | undefined;
+    selectCb?: ((arg0: number) => void) | undefined;
+};
+declare const __VLS_export: import("vue", { with: { "resolution-mode": "import" } }).DefineComponent<{}, {
+    smAndUp: import("vue", { with: { "resolution-mode": "import" } }).Ref<boolean>;
     toolboxOpen: any;
     toolboxToggleAction: {
         name: string;
@@ -19,28 +30,18 @@ declare const _default: import("vue").DefineComponent<{}, {
         active: any;
         callback: () => void;
     };
-    orderedGroups: import("vue").ComputedRef<(import("../buttonManager.js", { with: { "resolution-mode": "import" } }).ButtonComponent | import("./toolboxManager.js", { with: { "resolution-mode": "import" } }).ToolboxComponent)[]>;
+    orderedGroups: import("vue", { with: { "resolution-mode": "import" } }).ComputedRef<(import("../buttonManager.js", { with: { "resolution-mode": "import" } }).ButtonComponent | import("./toolboxManager.js", { with: { "resolution-mode": "import" } }).ToolboxComponent)[]>;
     zIndex: any;
-    zIndexMobile: import("vue").ComputedRef<any>;
-    isDefaultToolbox: import("vue").ComputedRef<boolean>;
+    zIndexMobile: import("vue", { with: { "resolution-mode": "import" } }).ComputedRef<any>;
+    isDefaultToolbox: import("vue", { with: { "resolution-mode": "import" } }).ComputedRef<boolean>;
     ToolboxType: {
         SINGLE: number;
         SELECT: number;
         GROUP: number;
     };
-    open: import("vue").Ref<boolean>;
+    open: import("vue", { with: { "resolution-mode": "import" } }).Ref<boolean>;
     bringToTop: () => void;
     openGroup(group: any): void;
-    toolboxHeight: import("vue").ComputedRef<number>;
-    xs: import("vue").Ref<boolean>;
-}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}, {}>;
-export default _default;
-export type ToolboxButtonGroup = {
-    id: string;
-    type: string;
-    icon: string;
-    title: string;
-    buttons: Array<import("../buttonManager.js").ButtonComponent>;
-    selected?: string | undefined;
-    selectCb?: ((arg0: number) => void) | undefined;
-};
+    toolboxHeight: import("vue", { with: { "resolution-mode": "import" } }).ComputedRef<number>;
+    xs: import("vue", { with: { "resolution-mode": "import" } }).Ref<boolean>;
+}, {}, {}, {}, import("vue", { with: { "resolution-mode": "import" } }).ComponentOptionsMixin, import("vue", { with: { "resolution-mode": "import" } }).ComponentOptionsMixin, {}, string, import("vue", { with: { "resolution-mode": "import" } }).PublicProps, Readonly<import("vue", { with: { "resolution-mode": "import" } }).ExtractPropTypes<{}>>, {}, {}>;

package/src/manager/toolbox/toolboxManager.d.ts

@@ -5,7 +5,7 @@
  * @param {function(ownerA:string, ownerB:string, order: string[]):number} [compareFn=sortByOwner] Per default components are sorted by owner: app first, then plugins
  * @returns {Array<ToolboxComponent|import("../buttonManager.js").ButtonComponent>}
  */
-export function getComponentsByOrder(components: Array<ToolboxComponent | import("../buttonManager.js").ButtonComponent>, order?: string[] | undefined, compareFn?: typeof sortByOwner): Array<ToolboxComponent | import("../buttonManager.js").ButtonComponent>;
+export function getComponentsByOrder(components: Array<ToolboxComponent | import("../buttonManager.js").ButtonComponent>, order?: string[], compareFn?: typeof sortByOwner): Array<ToolboxComponent | import("../buttonManager.js").ButtonComponent>;
 /**
  * Adds default groups for a toolboxManager.
  * Once requested, group id, icon and title are defined and cannot be changed or overwritten.
@@ -94,7 +94,7 @@ export type IToolboxManager = import("../../vcsUiApp.js").VcsComponentManager<To
  * @param {string[]} [order] order of owners to sort by
  * @returns {number}
  */
-declare function sortByOwner(compA: ToolboxComponent | import("../buttonManager.js").ButtonComponent, compB: ToolboxComponent | import("../buttonManager.js").ButtonComponent, order?: string[] | undefined): number;
+declare function sortByOwner(compA: ToolboxComponent | import("../buttonManager.js").ButtonComponent, compB: ToolboxComponent | import("../buttonManager.js").ButtonComponent, order?: string[]): number;
 /**
  * @typedef {import("../../vcsUiApp.js").VcsComponentManager<ToolboxComponent,ToolboxComponentOptions>} IToolboxManager
  */
@@ -164,7 +164,7 @@ declare class ToolboxManager implements IToolboxManager {
      * @returns {SingleToolboxComponent|SelectToolboxComponent|import("vue").ShallowReactive<GroupToolboxComponent>}
      */
     // @ts-ignore
-add(toolboxComponentOptions: SingleToolboxComponentOptions | SelectToolboxComponentOptions | GroupToolboxComponentOptions, owner: string | symbol, device?: Partial<Record<import("../navbarManager.js").Device, boolean>> | undefined): SingleToolboxComponent | SelectToolboxComponent | import("vue").ShallowReactive<GroupToolboxComponent>;
+add(toolboxComponentOptions: SingleToolboxComponentOptions | SelectToolboxComponentOptions | GroupToolboxComponentOptions, owner: string | symbol, device?: import("../navbarManager.js").DeviceOptions): SingleToolboxComponent | SelectToolboxComponent | import("vue").ShallowReactive<GroupToolboxComponent>;
     /**
      * removes all {@link ToolboxComponent}s of a specific owner and fires removed Events
      * @param {string|vcsAppSymbol} owner

package/src/manager/toolbox/toolboxManager.js

@@ -4,7 +4,7 @@ import { v4 as uuidv4 } from 'uuid';
 import { reactive, ref, shallowReactive } from 'vue';
 import { vcsAppSymbol } from '../../pluginHelper.js';
 import ButtonManager from '../buttonManager.js';
-import { ActionPattern } from '../../components/lists/VcsActionList.vue';
+import { actionPattern } from '../../components/lists/VcsActionList.ts.vue';
 import { getActionFromOptions } from '../../actions/actionHelper.js';
 import { deviceSymbol } from '../navbarManager.js';
 
@@ -337,7 +337,7 @@ class ToolboxManager {
     };
 
     if (type === ToolboxType.SINGLE) {
-      check(toolboxComponentOptions.action, ActionPattern);
+      check(toolboxComponentOptions.action, actionPattern);
       const action = getActionFromOptions(toolboxComponentOptions.action);
       /**
        * @type {SingleToolboxComponent}
@@ -350,7 +350,7 @@ class ToolboxManager {
       };
     } else if (type === ToolboxType.SELECT) {
       check(toolboxComponentOptions.action, {
-        ...ActionPattern,
+        ...actionPattern,
         selected: Function,
         currentIndex: Number,
         disabled: optional(Boolean),

package/src/manager/window/WindowComponent.vue.d.ts

@@ -1,4 +1,6 @@
-declare const _default: import("vue").DefineComponent<{
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: import("vue", { with: { "resolution-mode": "import" } }).DefineComponent<{
     windowState: {
         type: ObjectConstructor;
         required: true;
@@ -12,17 +14,17 @@ declare const _default: import("vue").DefineComponent<{
         required: true;
     };
 }, {
-    isDynamic: import("vue").ComputedRef<boolean>;
-    isChild: import("vue").ComputedRef<boolean>;
-    isDocked: import("vue").ComputedRef<boolean>;
-    isTabletWithOpenToolbar: import("vue").ComputedRef<any>;
-    isDynamicLeft: import("vue").ComputedRef<boolean>;
-    isDynamicRight: import("vue").ComputedRef<boolean>;
-    isDraggable: import("vue").Ref<boolean>;
+    isDynamic: import("vue", { with: { "resolution-mode": "import" } }).ComputedRef<boolean>;
+    isChild: import("vue", { with: { "resolution-mode": "import" } }).ComputedRef<boolean>;
+    isDocked: import("vue", { with: { "resolution-mode": "import" } }).ComputedRef<boolean>;
+    isTabletWithOpenToolbar: import("vue", { with: { "resolution-mode": "import" } }).ComputedRef<any>;
+    isDynamicLeft: import("vue", { with: { "resolution-mode": "import" } }).ComputedRef<boolean>;
+    isDynamicRight: import("vue", { with: { "resolution-mode": "import" } }).ComputedRef<boolean>;
+    isDraggable: import("vue", { with: { "resolution-mode": "import" } }).Ref<boolean>;
     dragStart: (e: DragEvent) => void;
     dragEnd: (endEvent: DragEvent) => void;
     mousedown: (e: MouseEvent) => void;
-}, any, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("mousedown" | "moved")[], "mousedown" | "moved", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+}, any, {}, {}, import("vue", { with: { "resolution-mode": "import" } }).ComponentOptionsMixin, import("vue", { with: { "resolution-mode": "import" } }).ComponentOptionsMixin, ("mousedown" | "moved")[], "mousedown" | "moved", import("vue", { with: { "resolution-mode": "import" } }).PublicProps, Readonly<import("vue", { with: { "resolution-mode": "import" } }).ExtractPropTypes<{
     windowState: {
         type: ObjectConstructor;
         required: true;
@@ -41,4 +43,3 @@ declare const _default: import("vue").DefineComponent<{
 }, {
     isOnTop: boolean;
 }, {}>;
-export default _default;

package/src/manager/window/WindowComponentHeader.vue

@@ -62,9 +62,9 @@
   import { VIcon, VDivider, VTooltip } from 'vuetify/components';
   import { computed, getCurrentInstance, ref } from 'vue';
   import { useDisplay } from 'vuetify';
-  import { createEllipseTooltip } from '../../components/composables.js';
-  import VcsButton from '../../components/buttons/VcsButton.vue';
-  import VcsActionButtonList from '../../components/buttons/VcsActionButtonList.vue';
+  import { createEllipseTooltip } from '../../components/composables.ts';
+  import VcsButton from '../../components/buttons/VcsButton.ts.vue';
+  import VcsActionButtonList from '../../components/buttons/VcsActionButtonList.ts.vue';
   import { createLinkAction } from '../../actions/actionHelper.js';
   import { useIconSize } from '../../vuePlugins/vuetify.js';
 

package/src/manager/window/WindowComponentHeader.vue.d.ts

@@ -1,4 +1,6 @@
-declare const _default: import("vue").DefineComponent<{
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: import("vue", { with: { "resolution-mode": "import" } }).DefineComponent<{
     windowState: {
         type: ObjectConstructor;
         required: true;
@@ -14,14 +16,14 @@ declare const _default: import("vue").DefineComponent<{
 }, {
     pin: () => void;
     close: () => void;
-    isDockable: import("vue").ComputedRef<any>;
-    translatedHeaderTitle: import("vue").ComputedRef<any>;
-    headerRef: import("vue").Ref<null>;
-    iconSize: import("vue").ComputedRef<number>;
-    headerTooltip: import("vue").ComputedRef<string>;
+    isDockable: import("vue", { with: { "resolution-mode": "import" } }).ComputedRef<any>;
+    translatedHeaderTitle: import("vue", { with: { "resolution-mode": "import" } }).ComputedRef<string>;
+    headerRef: import("vue", { with: { "resolution-mode": "import" } }).Ref<null>;
+    iconSize: import("vue", { with: { "resolution-mode": "import" } }).ComputedRef<number>;
+    headerTooltip: import("vue", { with: { "resolution-mode": "import" } }).ComputedRef<string>;
     infoAction: import("../../actions/actionHelper.js", { with: { "resolution-mode": "import" } }).VcsAction | undefined;
-    xs: import("vue").Ref<boolean>;
-}, any, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("close" | "pin")[], "close" | "pin", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    xs: import("vue", { with: { "resolution-mode": "import" } }).Ref<boolean>;
+}, any, {}, {}, import("vue", { with: { "resolution-mode": "import" } }).ComponentOptionsMixin, import("vue", { with: { "resolution-mode": "import" } }).ComponentOptionsMixin, ("close" | "pin")[], "close" | "pin", import("vue", { with: { "resolution-mode": "import" } }).PublicProps, Readonly<import("vue", { with: { "resolution-mode": "import" } }).ExtractPropTypes<{
     windowState: {
         type: ObjectConstructor;
         required: true;
@@ -40,4 +42,3 @@ declare const _default: import("vue").DefineComponent<{
 }, {
     isOnTop: boolean;
 }, {}>;
-export default _default;

package/src/manager/window/WindowManager.vue.d.ts

@@ -1,4 +1,6 @@
-declare const _default: import("vue").DefineComponent<{}, {
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: import("vue", { with: { "resolution-mode": "import" } }).DefineComponent<{}, {
     componentIds: WindowManager;
     getComponent: (id: any) => any;
     getHeaderComponent: (id: any) => any;
@@ -14,12 +16,11 @@ declare const _default: import("vue").DefineComponent<{}, {
         dx: number;
         dy: number;
     }) => void;
-    addMobileClass: import("vue").ComputedRef<boolean>;
-    addTabletClass: import("vue").ComputedRef<boolean>;
+    addMobileClass: import("vue", { with: { "resolution-mode": "import" } }).ComputedRef<boolean>;
+    addTabletClass: import("vue", { with: { "resolution-mode": "import" } }).ComputedRef<boolean>;
     onTouchStart: (event: TouchEvent) => void;
     onTouchMove: (event: TouchEvent) => void;
     onTouchEnd: (event: TouchEvent, id: string) => void;
-    isOblique: import("vue").Ref<boolean>;
-    xs: import("vue").Ref<boolean>;
-}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}, {}>;
-export default _default;
+    isOblique: import("vue", { with: { "resolution-mode": "import" } }).Ref<boolean>;
+    xs: import("vue", { with: { "resolution-mode": "import" } }).Ref<boolean>;
+}, {}, {}, {}, import("vue", { with: { "resolution-mode": "import" } }).ComponentOptionsMixin, import("vue", { with: { "resolution-mode": "import" } }).ComponentOptionsMixin, {}, string, import("vue", { with: { "resolution-mode": "import" } }).PublicProps, Readonly<import("vue", { with: { "resolution-mode": "import" } }).ExtractPropTypes<{}>>, {}, {}>;

package/src/manager/window/windowHelper.d.ts

@@ -23,7 +23,7 @@ export function getTargetSize(target: HTMLElement): DOMRect | null;
  * @param {number} [offsetY=0]
  * @returns {import("./windowManager.js").WindowPositionOptions}
  */
-export function getWindowPositionOptions(x: number, y: number, target: HTMLElement, alignment?: number | undefined, offsetX?: number | undefined, offsetY?: number | undefined): import("./windowManager.js").WindowPositionOptions;
+export function getWindowPositionOptions(x: number, y: number, target: HTMLElement, alignment?: WindowAlignment, offsetX?: number, offsetY?: number): import("./windowManager.js").WindowPositionOptions;
 /**
  * Get window position options based on a pixel in the map
  * @param {import("@vcmap-cesium/engine").Cartesian2} windowPosition - the window position, as retrieved from an InteractionEvent
@@ -31,7 +31,7 @@ export function getWindowPositionOptions(x: number, y: number, target: HTMLEleme
  * @param {WindowAlignment} [alignment]
  * @returns {import("./windowManager.js").WindowPositionOptions}
  */
-export function getWindowPositionOptionsFromMapEvent(windowPosition: import("@vcmap-cesium/engine").Cartesian2, target: HTMLElement, alignment?: number | undefined): import("./windowManager.js").WindowPositionOptions;
+export function getWindowPositionOptionsFromMapEvent(windowPosition: import("@vcmap-cesium/engine").Cartesian2, target: HTMLElement, alignment?: WindowAlignment): import("./windowManager.js").WindowPositionOptions;
 /**
  * Fits a window aligned top left, so it fits into the parent. This will change the alignment to be bottom or right depending
  * on if the window would not fit into the parent.
@@ -44,7 +44,7 @@ export function getWindowPositionOptionsFromMapEvent(windowPosition: import("@vc
  * @param {number} [offsetY=0]
  * @returns {import("./windowManager.js").WindowPositionOptions}
  */
-export function getFittedWindowPositionOptions(x: number, y: number, width: number, height: number, target: HTMLElement, offsetX?: number | undefined, offsetY?: number | undefined): import("./windowManager.js").WindowPositionOptions;
+export function getFittedWindowPositionOptions(x: number, y: number, width: number, height: number, target: HTMLElement, offsetX?: number, offsetY?: number): import("./windowManager.js").WindowPositionOptions;
 /**
  * Fits a window aligned top left, so it fits into currently active map. This will change the alignment to be bottom or right depending
  * on if the window would not fit into active map element.

package/src/manager/window/windowManager.d.ts

@@ -158,7 +158,7 @@ export type WindowComponentOptions<T = any> = {
     props?: T;
     provides?: Record<string, unknown>;
 };
-export type OptionsOrRef<T> = T | import('vue').Ref<T> | import('vue').ComputedRef<T>;
+export type OptionsOrRef<T> = T | import("vue").Ref<T> | import("vue").ComputedRef<T>;
 export type WindowStateOptions = {
     /**
      * be used to not show the header.

package/src/navigation/MapNavCompass.vue.d.ts

@@ -1,4 +1,6 @@
-declare const _default: import("vue").DefineComponent<{
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: import("vue", { with: { "resolution-mode": "import" } }).DefineComponent<{
     canEmit: {
         type: BooleanConstructor;
         default: boolean;
@@ -8,10 +10,10 @@ declare const _default: import("vue").DefineComponent<{
         default: boolean;
     };
 }, {
-    alignment: import("vue").Ref<string>;
+    alignment: import("vue", { with: { "resolution-mode": "import" } }).Ref<string>;
 }, any, {}, {
     emit(event: any, dir: any): void;
-}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "direction-click"[], "direction-click", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+}, import("vue", { with: { "resolution-mode": "import" } }).ComponentOptionsMixin, import("vue", { with: { "resolution-mode": "import" } }).ComponentOptionsMixin, "direction-click"[], "direction-click", import("vue", { with: { "resolution-mode": "import" } }).PublicProps, Readonly<import("vue", { with: { "resolution-mode": "import" } }).ExtractPropTypes<{
     canEmit: {
         type: BooleanConstructor;
         default: boolean;
@@ -26,4 +28,3 @@ declare const _default: import("vue").DefineComponent<{
     canEmit: boolean;
     hideTicks: boolean;
 }, {}>;
-export default _default;