@vcmap/ui 6.3.11 → 7.0.0-rc.1

package/src/components/tables/{VcsTable.vue → VcsTable.ts.vue}

@@ -11,45 +11,48 @@
         <vcs-table-cell
           :title="item.value"
           :width="valueHeader.width"
-          :tag="getTag(tags, item.key)"
-          :tag-options="getTagOptions(tags, item.key)"
+          :tag="getTag(tags!, item.key)"
+          :tag-options="getTagOptions(tags!, item.key)"
         >
         </vcs-table-cell>
       </tr>
     </template>
   </VcsDataTable>
 </template>
-<script>
-  import { computed } from 'vue';
-  import VcsTableCell from './VcsTableCell.vue';
-  import VcsDataTable from './VcsDataTable.vue';
 
-  /**
-   * @typedef {Object} TableItem
-   * @property {string} key
-   * @property {string} value
-   */
+<script lang="ts">
+  import type { PropType } from 'vue';
+  import { computed, defineComponent } from 'vue';
+  import VcsTableCell from './VcsTableCell.ts.vue';
+  import VcsDataTable from './VcsDataTable.ts.vue';
+  import type { HTMLTagOptions } from '../../featureInfo/abstractFeatureInfoView.js';
+
+  type TableItem = {
+    key: string;
+    value: string;
+    group?: string;
+  };
 
-  /**
-   * @param {Object} attributes
-   * @param {Array<TableItem>} [items]
-   * @param {string} [parent]
-   * @returns {Array<TableItem>}
-   */
   export function attributesToItems(
-    attributes,
-    items = [],
-    parent = undefined,
-  ) {
-    const nestedKey = (key, nested) => (nested ? `${nested}.${key}` : key);
+    attributes: Record<string, unknown>,
+    items: TableItem[] = [],
+    parent?: string,
+  ): TableItem[] {
+    const nestedKey = (key: string, nested: string | undefined): string =>
+      nested ? `${nested}.${key}` : key;
     Object.entries(attributes).forEach(([key, value]) => {
       if (value instanceof Object) {
-        attributesToItems(value, items, nestedKey(key, parent));
+        attributesToItems(
+          value as Record<string, unknown>,
+          items,
+          nestedKey(key, parent),
+        );
       } else {
-        const item = { key: nestedKey(key, parent), value };
-        if (parent) {
-          item.group = parent;
-        }
+        const item = {
+          key: nestedKey(key, parent),
+          value: String(value),
+          group: parent,
+        };
         items.push(item);
       }
     });
@@ -58,9 +61,8 @@
 
   /**
    * Defines which HTML tags can be used within the VcsTable value column and provides default options
-   * @type {Object<string,Object<string,*>>}
    */
-  export const defaultTagOptions = {
+  export const defaultTagOptions: Record<string, Record<string, unknown>> = {
     a: {
       href: undefined,
       target: '_blank',
@@ -95,22 +97,20 @@
     },
   };
 
-  /**
-   * @param {import("../../featureInfo/abstractFeatureInfoView.js").HTMLTagOptions} tags
-   * @param {string} key
-   * @returns {string}
-   */
-  export function getTag(tags, key) {
+  export function getTag(
+    tags: HTMLTagOptions,
+    key: keyof HTMLTagOptions,
+  ): string {
+    // @ts-expect-error access tag property
     return tags?.[key]?.tag ?? 'div';
   }
 
-  /**
-   * @param {Object} tags
-   * @param {string} key
-   * @returns {import("../../featureInfo/abstractFeatureInfoView.js").HTMLTagOptions|Record<never, never>}
-   */
-  export function getTagOptions(tags, key) {
+  export function getTagOptions(
+    tags: HTMLTagOptions,
+    key: keyof HTMLTagOptions,
+  ): Record<string, unknown> {
     if (tags?.[key]) {
+      // @ts-expect-error access tag property
       return { ...defaultTagOptions[tags[key].tag], ...tags[key] };
     }
     return {};
@@ -124,47 +124,57 @@
    * @vue-prop {{title: string, key: 'value', width: string|undefined}} [valueHeader] - optional header defining the value column
    * @vue-computed {Array<TableItem>} items - from attributes derived table items
    */
-  export default {
+  export default defineComponent({
     name: 'VcsTable',
-    components: {
-      VcsTableCell,
-      VcsDataTable,
-    },
+    components: { VcsTableCell, VcsDataTable },
     props: {
       attributes: {
-        type: Object,
+        type: Object as PropType<Record<string, unknown>>,
         required: true,
       },
       tags: {
-        type: Object,
+        type: Object as PropType<HTMLTagOptions>,
         default: undefined,
       },
       keyHeader: {
-        type: Object,
+        type: Object as PropType<{
+          title: string;
+          key: 'key';
+          width: string | undefined;
+        }>,
         default: () => ({
           title: 'components.vcsTable.key',
           key: 'key',
           width: '128px',
         }),
-        validator: (value) => value.key === 'key',
+        validator: (value: {
+          title: string;
+          key: 'key';
+          width: string | undefined;
+        }) => value.key === 'key',
       },
       valueHeader: {
-        type: Object,
+        type: Object as PropType<{
+          title: string;
+          key: 'value';
+          width: string | undefined;
+        }>,
         default: () => ({
           title: 'components.vcsTable.value',
           key: 'value',
           width: '192px',
         }),
-        validator: (value) => value.key === 'value',
+        validator: (value: {
+          title: string;
+          key: 'value';
+          width: string | undefined;
+        }) => value.key === 'value',
       },
     },
     setup(props) {
-      /**
-       * @type {ComputedRef<Array<TableItem>>}
-       */
-      const items = computed(() => {
-        return attributesToItems(props.attributes);
-      });
+      const items = computed<Array<TableItem>>(() =>
+        attributesToItems(props.attributes),
+      );
 
       return {
         items,
@@ -172,7 +182,7 @@
         getTagOptions,
       };
     },
-  };
+  });
 </script>
 
 <style lang="scss" scoped>
@@ -181,6 +191,4 @@
       max-width: 100% !important;
     }
   }
-  :deep(.v-table__wrapper) {
-  }
 </style>

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

@@ -0,0 +1,127 @@
+import type { PropType } from 'vue';
+import type { HTMLTagOptions } from '../../featureInfo/abstractFeatureInfoView.js';
+type TableItem = {
+    key: string;
+    value: string;
+    group?: string;
+};
+export declare function attributesToItems(attributes: Record<string, unknown>, items?: TableItem[], parent?: string): TableItem[];
+/**
+ * Defines which HTML tags can be used within the VcsTable value column and provides default options
+ */
+export declare const defaultTagOptions: Record<string, Record<string, unknown>>;
+export declare function getTag(tags: HTMLTagOptions, key: keyof HTMLTagOptions): string;
+export declare function getTagOptions(tags: HTMLTagOptions, key: keyof HTMLTagOptions): Record<string, unknown>;
+/**
+ * @description A table view for feature attributes using VcsDataTable
+ * @vue-prop {Object} attributes - feature's attributes
+ * @vue-prop {Object} tags - Allows to render the value column for specific attribute keys with special html elements. See 'defaultTagOptions' for supported html tags.
+ * @vue-prop {{title: string, key: 'key', width: string|undefined}} [keyHeader] - optional header defining the key column
+ * @vue-prop {{title: string, key: 'value', width: string|undefined}} [valueHeader] - optional header defining the value column
+ * @vue-computed {Array<TableItem>} items - from attributes derived table items
+ */
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: import("vue", { with: { "resolution-mode": "import" } }).DefineComponent<{
+    attributes: {
+        type: PropType<Record<string, unknown>>;
+        required: true;
+    };
+    tags: {
+        type: PropType<HTMLTagOptions>;
+        default: undefined;
+    };
+    keyHeader: {
+        type: PropType<{
+            title: string;
+            key: "key";
+            width: string | undefined;
+        }>;
+        default: () => {
+            title: string;
+            key: string;
+            width: string;
+        };
+        validator: (value: {
+            title: string;
+            key: "key";
+            width: string | undefined;
+        }) => boolean;
+    };
+    valueHeader: {
+        type: PropType<{
+            title: string;
+            key: "value";
+            width: string | undefined;
+        }>;
+        default: () => {
+            title: string;
+            key: string;
+            width: string;
+        };
+        validator: (value: {
+            title: string;
+            key: "value";
+            width: string | undefined;
+        }) => boolean;
+    };
+}, {
+    items: import("vue", { with: { "resolution-mode": "import" } }).ComputedRef<TableItem[]>;
+    getTag: typeof getTag;
+    getTagOptions: typeof getTagOptions;
+}, unknown, {}, {}, 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<{
+    attributes: {
+        type: PropType<Record<string, unknown>>;
+        required: true;
+    };
+    tags: {
+        type: PropType<HTMLTagOptions>;
+        default: undefined;
+    };
+    keyHeader: {
+        type: PropType<{
+            title: string;
+            key: "key";
+            width: string | undefined;
+        }>;
+        default: () => {
+            title: string;
+            key: string;
+            width: string;
+        };
+        validator: (value: {
+            title: string;
+            key: "key";
+            width: string | undefined;
+        }) => boolean;
+    };
+    valueHeader: {
+        type: PropType<{
+            title: string;
+            key: "value";
+            width: string | undefined;
+        }>;
+        default: () => {
+            title: string;
+            key: string;
+            width: string;
+        };
+        validator: (value: {
+            title: string;
+            key: "value";
+            width: string | undefined;
+        }) => boolean;
+    };
+}>>, {
+    tags: HTMLTagOptions;
+    keyHeader: {
+        title: string;
+        key: "key";
+        width: string | undefined;
+    };
+    valueHeader: {
+        title: string;
+        key: "value";
+        width: string | undefined;
+    };
+}, {}>;

package/src/components/tables/{VcsTableCell.vue → VcsTableCell.ts.vue}

@@ -1,4 +1,5 @@
-<script setup>
+<script setup lang="ts">
+  import type { PropType } from 'vue';
   import { ref, computed } from 'vue';
   import { VTooltip } from 'vuetify/components';
   import { createEllipseTooltip } from '../composables.js';
@@ -17,20 +18,20 @@
       default: 'div',
     },
     tagOptions: {
-      type: Object,
-      default: () => {},
+      type: Object as PropType<Record<string, unknown>>,
+      default: () => ({}),
     },
   });
 
-  const td = ref(null);
+  const td = ref<HTMLElement | undefined>(undefined);
 
   const tooltip = createEllipseTooltip(
     computed(() => td.value),
     computed(() => undefined),
-    computed(() => props.title),
+    computed(() => String(props.title)),
   );
 
-  const hasWhiteSpace = computed(() => /\s/.test(props.title));
+  const hasWhiteSpace = computed(() => /\s/.test(String(props.title)));
   // important: tooltip has evaluated before single-line and multi-line class are applied
   const isSingleLine = computed(() => tooltip.value && !hasWhiteSpace.value);
   const isMultiLine = computed(() => tooltip.value && hasWhiteSpace.value);

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

@@ -0,0 +1,43 @@
+import type { PropType } from 'vue';
+declare const __VLS_export: import("vue", { with: { "resolution-mode": "import" } }).DefineComponent<{
+    title: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: undefined;
+    };
+    width: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: undefined;
+    };
+    tag: {
+        type: StringConstructor;
+        default: string;
+    };
+    tagOptions: {
+        type: PropType<Record<string, unknown>>;
+        default: () => {};
+    };
+}, unknown, unknown, {}, {}, 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<{
+    title: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: undefined;
+    };
+    width: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: undefined;
+    };
+    tag: {
+        type: StringConstructor;
+        default: string;
+    };
+    tagOptions: {
+        type: PropType<Record<string, unknown>>;
+        default: () => {};
+    };
+}>>, {
+    title: string | number;
+    width: string | number;
+    tag: string;
+    tagOptions: Record<string, unknown>;
+}, {}>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/src/components/vector-properties/VcsFeatureEditingWindow.vue

@@ -71,8 +71,8 @@
     pointVectorProperties,
     nonPointVectorProperties,
   } from './VcsVectorPropertiesComponent.vue';
-  import VcsFormSection from '../section/VcsFormSection.vue';
-  import VcsSnapTo from './VcsSnapTo.vue';
+  import VcsFormSection from '../section/VcsFormSection.ts.vue';
+  import VcsSnapTo from './VcsSnapTo.ts.vue';
   import VcsFeatureInputEditor from './VcsFeatureInputEditor.vue';
 
   /**

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

@@ -1,5 +1,3 @@
-/// <reference types="@vcmap-cesium/engine" />
-/// <reference types="@vcmap/core/dist/cesium.js" />
 /**
  * Returns the allowed transformation modes for the provided geometry types and number of features. Rotate is e.g. not allowed for a single point but for multiple points.
  * @param {Set<GeometryType>} geometryTypes A set with all geometry types of the features.
@@ -15,7 +13,20 @@ export namespace EditorTransformationIcons {
     let scale: string;
     let extrude: string;
 }
-declare const _default: import("vue").DefineComponent<{
+declare const _default: typeof __VLS_export;
+export default _default;
+export type EditorManager = {
+    currentLayer: import("vue").ShallowRef<import("@vcmap/core").Layer | undefined>;
+    currentFeatures: import("vue").ShallowRef<import("ol").Feature[]>;
+    currentEditSession: import("vue").ShallowRef<import("@vcmap/core").EditGeometrySession | import("@vcmap/core").EditFeaturesSession | undefined>;
+    currentSession: import("vue").ShallowRef<import("@vcmap/core").SelectFeaturesSession | import("@vcmap/core").CreateFeatureSession<import("@vcmap/core").GeometryType> | undefined>;
+    stopEditing: () => void;
+    startEditSession: (arg0: import("ol").Feature | undefined) => Promise<void> | void;
+    startTransformSession: (arg0: import("@vcmap/core").TransformationMode, arg1: import("ol").Feature[] | undefined) => Promise<void> | void;
+};
+import { GeometryType } from '@vcmap/core';
+import { TransformationMode } from '@vcmap/core';
+declare const __VLS_export: import("vue", { with: { "resolution-mode": "import" } }).DefineComponent<{
     allowedVectorProperties: {
         type: ArrayConstructor;
         default: () => string[];
@@ -49,17 +60,17 @@ declare const _default: import("vue").DefineComponent<{
         default: boolean;
     };
 }, {
-    featureProperties: import("vue").ShallowRef<any>;
-    session: import("vue").ShallowRef<import("@vcmap/core", { with: { "resolution-mode": "import" } }).SelectFeaturesSession | import("@vcmap/core", { with: { "resolution-mode": "import" } }).CreateFeatureSession<GeometryType> | undefined>;
-    snapTo: import("vue").WritableComputedRef<never[] | undefined>;
+    featureProperties: import("vue", { with: { "resolution-mode": "import" } }).ShallowRef<any>;
+    session: import("vue", { with: { "resolution-mode": "import" } }).ShallowRef<import("@vcmap/core", { with: { "resolution-mode": "import" } }).SelectFeaturesSession | import("@vcmap/core", { with: { "resolution-mode": "import" } }).CreateFeatureSession<GeometryType> | undefined>;
+    snapTo: import("vue", { with: { "resolution-mode": "import" } }).WritableComputedRef<never[] | undefined>;
     SessionType: typeof SessionType;
-    currentTransformationMode: import("vue").Ref<any>;
+    currentTransformationMode: import("vue", { with: { "resolution-mode": "import" } }).Ref<any>;
     TransformationMode: typeof TransformationMode;
-    availableModifyActions: import("vue").ShallowRef<never[]>;
-    availableVectorProperties: import("vue").ShallowRef<never[]>;
-    is3D: import("vue").Ref<boolean>;
-    is2DFeature: import("vue").ComputedRef<boolean>;
-    isGeometryEditing: import("vue").ComputedRef<boolean>;
+    availableModifyActions: import("vue", { with: { "resolution-mode": "import" } }).ShallowRef<never[]>;
+    availableVectorProperties: import("vue", { with: { "resolution-mode": "import" } }).ShallowRef<never[]>;
+    is3D: import("vue", { with: { "resolution-mode": "import" } }).Ref<boolean>;
+    is2DFeature: import("vue", { with: { "resolution-mode": "import" } }).ComputedRef<boolean>;
+    isGeometryEditing: import("vue", { with: { "resolution-mode": "import" } }).ComputedRef<boolean>;
     updateFeatureProperties: (update: import("@vcmap/core").VectorPropertiesOptions) => void;
     defaultVectorProperties: {
         altitudeMode?: import("@vcmap/core/dist/src/layer/vectorProperties.js", { with: { "resolution-mode": "import" } }).AltitudeModeType | undefined;
@@ -73,8 +84,8 @@ declare const _default: import("vue").DefineComponent<{
         extrudedHeight?: number | undefined;
         storeysAboveGround?: number | undefined;
         storeysBelowGround?: number | undefined;
-        storeyHeightsAboveGround?: number | number[] | undefined;
-        storeyHeightsBelowGround?: number | number[] | undefined;
+        storeyHeightsAboveGround?: number[] | number | undefined;
+        storeyHeightsBelowGround?: number[] | number | undefined;
         modelUrl?: string | undefined;
         modelScaleX?: number | undefined;
         modelScaleY?: number | undefined;
@@ -116,18 +127,18 @@ declare const _default: import("vue").DefineComponent<{
                     x: number;
                     y: number;
                     z: number;
-                    clone: (result?: import("@vcmap-cesium/engine", { with: { "resolution-mode": "import" } }).Cartesian3 | undefined) => import("@vcmap-cesium/engine", { with: { "resolution-mode": "import" } }).Cartesian3;
-                    equals: (right?: import("@vcmap-cesium/engine", { with: { "resolution-mode": "import" } }).Cartesian3 | undefined) => boolean;
-                    equalsEpsilon: (right?: import("@vcmap-cesium/engine", { with: { "resolution-mode": "import" } }).Cartesian3 | undefined, relativeEpsilon?: number | undefined, absoluteEpsilon?: number | undefined) => boolean;
+                    clone: (result?: import("@vcmap-cesium/engine", { with: { "resolution-mode": "import" } }).Cartesian3) => import("@vcmap-cesium/engine", { with: { "resolution-mode": "import" } }).Cartesian3;
+                    equals: (right?: import("@vcmap-cesium/engine", { with: { "resolution-mode": "import" } }).Cartesian3) => boolean;
+                    equalsEpsilon: (right?: import("@vcmap-cesium/engine", { with: { "resolution-mode": "import" } }).Cartesian3, relativeEpsilon?: number, absoluteEpsilon?: number) => boolean;
                     toString: () => string;
                 } | undefined;
                 innerRadii?: {
                     x: number;
                     y: number;
                     z: number;
-                    clone: (result?: import("@vcmap-cesium/engine", { with: { "resolution-mode": "import" } }).Cartesian3 | undefined) => import("@vcmap-cesium/engine", { with: { "resolution-mode": "import" } }).Cartesian3;
-                    equals: (right?: import("@vcmap-cesium/engine", { with: { "resolution-mode": "import" } }).Cartesian3 | undefined) => boolean;
-                    equalsEpsilon: (right?: import("@vcmap-cesium/engine", { with: { "resolution-mode": "import" } }).Cartesian3 | undefined, relativeEpsilon?: number | undefined, absoluteEpsilon?: number | undefined) => boolean;
+                    clone: (result?: import("@vcmap-cesium/engine", { with: { "resolution-mode": "import" } }).Cartesian3) => import("@vcmap-cesium/engine", { with: { "resolution-mode": "import" } }).Cartesian3;
+                    equals: (right?: import("@vcmap-cesium/engine", { with: { "resolution-mode": "import" } }).Cartesian3) => boolean;
+                    equalsEpsilon: (right?: import("@vcmap-cesium/engine", { with: { "resolution-mode": "import" } }).Cartesian3, relativeEpsilon?: number, absoluteEpsilon?: number) => boolean;
                     toString: () => string;
                 } | undefined;
                 minimumClock?: number | undefined;
@@ -149,18 +160,18 @@ declare const _default: import("vue").DefineComponent<{
                     x: number;
                     y: number;
                     z: number;
-                    clone: (result?: import("@vcmap-cesium/engine", { with: { "resolution-mode": "import" } }).Cartesian3 | undefined) => import("@vcmap-cesium/engine", { with: { "resolution-mode": "import" } }).Cartesian3;
-                    equals: (right?: import("@vcmap-cesium/engine", { with: { "resolution-mode": "import" } }).Cartesian3 | undefined) => boolean;
-                    equalsEpsilon: (right?: import("@vcmap-cesium/engine", { with: { "resolution-mode": "import" } }).Cartesian3 | undefined, relativeEpsilon?: number | undefined, absoluteEpsilon?: number | undefined) => boolean;
+                    clone: (result?: import("@vcmap-cesium/engine", { with: { "resolution-mode": "import" } }).Cartesian3) => import("@vcmap-cesium/engine", { with: { "resolution-mode": "import" } }).Cartesian3;
+                    equals: (right?: import("@vcmap-cesium/engine", { with: { "resolution-mode": "import" } }).Cartesian3) => boolean;
+                    equalsEpsilon: (right?: import("@vcmap-cesium/engine", { with: { "resolution-mode": "import" } }).Cartesian3, relativeEpsilon?: number, absoluteEpsilon?: number) => boolean;
                     toString: () => string;
                 };
                 maximum: {
                     x: number;
                     y: number;
                     z: number;
-                    clone: (result?: import("@vcmap-cesium/engine", { with: { "resolution-mode": "import" } }).Cartesian3 | undefined) => import("@vcmap-cesium/engine", { with: { "resolution-mode": "import" } }).Cartesian3;
-                    equals: (right?: import("@vcmap-cesium/engine", { with: { "resolution-mode": "import" } }).Cartesian3 | undefined) => boolean;
-                    equalsEpsilon: (right?: import("@vcmap-cesium/engine", { with: { "resolution-mode": "import" } }).Cartesian3 | undefined, relativeEpsilon?: number | undefined, absoluteEpsilon?: number | undefined) => boolean;
+                    clone: (result?: import("@vcmap-cesium/engine", { with: { "resolution-mode": "import" } }).Cartesian3) => import("@vcmap-cesium/engine", { with: { "resolution-mode": "import" } }).Cartesian3;
+                    equals: (right?: import("@vcmap-cesium/engine", { with: { "resolution-mode": "import" } }).Cartesian3) => boolean;
+                    equalsEpsilon: (right?: import("@vcmap-cesium/engine", { with: { "resolution-mode": "import" } }).Cartesian3, relativeEpsilon?: number, absoluteEpsilon?: number) => boolean;
                     toString: () => string;
                 };
                 vertexFormat?: {
@@ -173,7 +184,7 @@ declare const _default: import("vue").DefineComponent<{
                 } | undefined;
             } | undefined;
             depthFailColor?: string | number[] | {
-                setTransform: (transform?: DOMMatrix2DInit | undefined) => void;
+                setTransform: (transform?: DOMMatrix2DInit) => void;
             } | {
                 addColorStop: (offset: number, color: string) => void;
             } | undefined;
@@ -182,8 +193,8 @@ declare const _default: import("vue").DefineComponent<{
         } | undefined;
         baseUrl?: string | undefined;
     };
-    showInputs: import("vue").ComputedRef<boolean>;
-}, any, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    showInputs: import("vue", { with: { "resolution-mode": "import" } }).ComputedRef<boolean>;
+}, 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<{
     allowedVectorProperties: {
         type: ArrayConstructor;
         default: () => string[];
@@ -226,16 +237,4 @@ declare const _default: import("vue").DefineComponent<{
     showSnapping: boolean;
     showInputEditor: boolean;
 }, {}>;
-export default _default;
-export type EditorManager = {
-    currentLayer: import("vue").ShallowRef<import("@vcmap/core").Layer | undefined>;
-    currentFeatures: import("vue").ShallowRef<import("ol").Feature[]>;
-    currentEditSession: import("vue").ShallowRef<import("@vcmap/core").EditGeometrySession | import("@vcmap/core").EditFeaturesSession | undefined>;
-    currentSession: import("vue").ShallowRef<import("@vcmap/core").SelectFeaturesSession | import("@vcmap/core").CreateFeatureSession<import("@vcmap/core").GeometryType> | undefined>;
-    stopEditing: () => void;
-    startEditSession: (arg0: import("ol").Feature | undefined) => Promise<void> | void;
-    startTransformSession: (arg0: import("@vcmap/core").TransformationMode, arg1: import("ol").Feature[] | undefined) => Promise<void> | void;
-};
-import { GeometryType } from '@vcmap/core';
-import { TransformationMode } from '@vcmap/core';
 import { SessionType } from '@vcmap/core';

package/src/components/vector-properties/VcsFeatureInputEditor.vue

@@ -65,9 +65,9 @@
     Projection,
   } from '@vcmap/core';
   import { getLogger } from '@vcsuite/logger';
-  import VcsLabel from '../form-inputs-controls/VcsLabel.vue';
-  import VcsTextField from '../form-inputs-controls/VcsTextField.vue';
-  import VcsToolButton from '../buttons/VcsToolButton.vue';
+  import VcsLabel from '../form-inputs-controls/VcsLabel.ts.vue';
+  import VcsTextField from '../form-inputs-controls/VcsTextField.ts.vue';
+  import VcsToolButton from '../buttons/VcsToolButton.ts.vue';
 
   /**
    * @description Component to edit the position of a feature in a vector layer. Currently

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

@@ -1,17 +1,18 @@
-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<{
     is3D: {
         type: BooleanConstructor;
         required: true;
     };
 }, {
-    isEdited: import("vue").Ref<boolean>;
-    coordinates: import("vue").Ref<number[]>;
+    isEdited: import("vue", { with: { "resolution-mode": "import" } }).Ref<boolean>;
+    coordinates: import("vue", { with: { "resolution-mode": "import" } }).Ref<number[]>;
     apply: () => void;
     cancel: () => 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<{
     is3D: {
         type: BooleanConstructor;
         required: true;
     };
 }>>, {}, {}>;
-export default _default;

package/src/components/vector-properties/VcsFeatureTransforms.vue

@@ -127,8 +127,8 @@
   } from '@vcmap/core';
   import { VSheet, VContainer, VRow, VCol, VIcon } from 'vuetify/components';
   import { inject, ref, watch } from 'vue';
-  import VcsButton from '../buttons/VcsButton.vue';
-  import VcsTextField from '../form-inputs-controls/VcsTextField.vue';
+  import VcsButton from '../buttons/VcsButton.ts.vue';
+  import VcsTextField from '../form-inputs-controls/VcsTextField.ts.vue';
 
   /**
    * A component to handle transforms applied to features of an editor manager. Must have a manager provided.