@vcmap/ui 6.3.10 → 7.0.0-rc.1

package/src/components/flight/VcsFlightAnchorsComponent.ts.vue.d.ts

@@ -0,0 +1,53 @@
+import type { VcsAction } from '../../actions/actionHelper.js';
+import type { ItemMovedEvent } from '../lists/dragHelper.js';
+export declare function durationRule(value: number | string): boolean | string;
+/**
+ * @description A component for editing flight anchors.
+ * Requires a flightInstance to be provided via vue-provide.
+ * @vue-prop {string} [expandable=false] - anchors section expandable
+ * @vue-prop {string} [parentId] - id of the window, the VcsFlightComponent is used in
+ * @vue-prop {string} [owner] - owner of the window, e.g. a plugin name
+ */
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: import("vue", { with: { "resolution-mode": "import" } }).DefineComponent<{
+    expandable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    parentId: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    owner: {
+        type: (SymbolConstructor | StringConstructor)[];
+        default: symbol;
+    };
+}, {
+    addAnchorAction: VcsAction;
+    addAnchorAt: (index?: number) => void;
+    title: import("vue", { with: { "resolution-mode": "import" } }).Ref<string>;
+    items: import("vue", { with: { "resolution-mode": "import" } }).Ref<import("../../manager/collectionManager/collectionComponentClass.js", { with: { "resolution-mode": "import" } }).CollectionComponentListItem[]>;
+    draggable: import("vue", { with: { "resolution-mode": "import" } }).Ref<boolean>;
+    actions: import("vue", { with: { "resolution-mode": "import" } }).ComputedRef<VcsAction[]>;
+    move(event: ItemMovedEvent): void;
+    durationRule: typeof durationRule;
+    showDuration(index: number): boolean;
+}, 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<{
+    expandable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    parentId: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    owner: {
+        type: (SymbolConstructor | StringConstructor)[];
+        default: symbol;
+    };
+}>>, {
+    expandable: boolean;
+    parentId: string;
+    owner: string | symbol;
+}, {}>;

package/src/components/flight/{VcsFlightComponent.vue → VcsFlightComponent.ts.vue}

@@ -19,7 +19,7 @@
         <v-row no-gutters v-if="!hideName">
           <v-col cols="6">
             <VcsLabel :html-for="`${cid}-name`" required>
-              {{ $t('components.flight.name') }}
+              {{ $st('components.flight.name') }}
             </VcsLabel>
           </v-col>
           <v-col>
@@ -29,14 +29,14 @@
         <v-row no-gutters v-if="!hideTitle">
           <v-col cols="6">
             <VcsLabel :html-for="`${cid}-title`">
-              {{ $t('components.flight.title') }}
+              {{ $st('components.flight.title') }}
             </VcsLabel>
           </v-col>
           <v-col>
             <VcsTextField
               :id="`${cid}-title`"
               clearable
-              :placeholder="$t('components.flight.titlePlaceholder')"
+              :placeholder="$st('components.flight.titlePlaceholder')"
               v-model="title"
             />
           </v-col>
@@ -44,7 +44,7 @@
         <v-row no-gutters v-if="!hideInterpolation">
           <v-col cols="6">
             <VcsLabel :html-for="`${cid}-interpolation`">
-              {{ $t('components.flight.interpolation') }}
+              {{ $st('components.flight.interpolation') }}
             </VcsLabel>
           </v-col>
           <v-col>
@@ -61,7 +61,7 @@
         <v-row no-gutters v-if="!hideDuration">
           <v-col cols="6">
             <VcsLabel :html-for="`${cid}-duration`">
-              {{ $t('components.flight.duration') }}
+              {{ $st('components.flight.duration') }}
             </VcsLabel>
           </v-col>
           <v-col>
@@ -94,34 +94,33 @@
   </v-sheet>
 </template>
 
-<script>
-  import { computed, onUnmounted, ref, inject } from 'vue';
+<script lang="ts">
+  import { computed, defineComponent, onUnmounted, ref, inject } from 'vue';
   import { VSheet, VContainer, VRow, VCol, VDivider } from 'vuetify/components';
+  import type { FlightInstance } from '@vcmap/core';
   import { getSplineAndTimesForInstance } from '@vcmap/core';
-  import VcsFormSection from '../section/VcsFormSection.vue';
-  import VcsLabel from '../form-inputs-controls/VcsLabel.vue';
-  import VcsTextField from '../form-inputs-controls/VcsTextField.vue';
-  import VcsSelect from '../form-inputs-controls/VcsSelect.vue';
-  import VcsCheckbox from '../form-inputs-controls/VcsCheckbox.vue';
+  import VcsFormSection from '../section/VcsFormSection.ts.vue';
+  import VcsLabel from '../form-inputs-controls/VcsLabel.ts.vue';
+  import VcsTextField from '../form-inputs-controls/VcsTextField.ts.vue';
+  import VcsSelect from '../form-inputs-controls/VcsSelect.ts.vue';
+  import VcsCheckbox from '../form-inputs-controls/VcsCheckbox.ts.vue';
   import VcsFlightAnchorsComponent, {
     durationRule,
-  } from './VcsFlightAnchorsComponent.vue';
-  import VcsFlightPlayer from './VcsFlightPlayer.vue';
+  } from './VcsFlightAnchorsComponent.ts.vue';
+  import VcsFlightPlayer from './VcsFlightPlayer.ts.vue';
   import { vcsAppSymbol } from '../../pluginHelper.js';
   import {
     getProvidedFlightInstance,
     setupFlightAnchorEditingListener,
   } from './composables.js';
   import { useComponentId } from '../composables.js';
+  import type VcsUiApp from '../../vcsUiApp.js';
 
-  /**
-   * @param {import("@vcmap/core").FlightInstance} instance
-   * @returns {number}
-   */
-  function getFlightDuration(instance) {
+  function getFlightDuration(instance: FlightInstance): number {
     if (instance.isValid()) {
       const { times } = getSplineAndTimesForInstance(instance);
-      return Math.round(times.at(-1) * 100) / 100;
+      const lastTime = times.at(-1);
+      return lastTime !== undefined ? Math.round(lastTime * 100) / 100 : 0;
     }
     return 0;
   }
@@ -140,7 +139,7 @@
    * @vue-prop {string} [parentId] - id of the window, the VcsFlightComponent is used in
    * @vue-prop {string} [owner] - owner of the window, e.g. a plugin name
    */
-  export default {
+  export default defineComponent({
     name: 'VcsFlightComponent',
     components: {
       VcsFlightPlayer,
@@ -199,7 +198,7 @@
       },
     },
     setup() {
-      const app = inject('vcsApp');
+      const app = inject('vcsApp') as VcsUiApp;
       const flightInstance = getProvidedFlightInstance();
       const loop = ref(flightInstance.loop);
       const interpolationValue = ref(flightInstance.interpolation);
@@ -226,7 +225,9 @@
       );
 
       onUnmounted(() => {
-        flightInstanceListeners.forEach((cb) => cb());
+        flightInstanceListeners.forEach((cb) => {
+          cb();
+        });
         editingListener();
       });
 
@@ -234,9 +235,9 @@
 
       return {
         name: flightInstance.name,
-        title: computed({
+        title: computed<string>({
           get() {
-            return flightInstance?.properties?.title;
+            return flightInstance?.properties?.title as string;
           },
           set(value) {
             if (flightInstance.properties) {
@@ -260,7 +261,7 @@
             return flightDuration.value;
           },
           set(value) {
-            const v = parseFloat(value);
+            const v = parseFloat(String(value));
             if (Number.isFinite(v) && v > 0 && flightDuration.value > 0) {
               const factor = v / flightDuration.value;
               [...flightInstance.anchors].forEach((anchor) => {
@@ -275,13 +276,13 @@
             return loop.value;
           },
           set(value) {
-            loop.value = !!value;
-            flightInstance.loop = !!value;
+            loop.value = value;
+            flightInstance.loop = value;
           },
         }),
         disablePlayer,
         cid,
       };
     },
-  };
+  });
 </script>

package/src/components/flight/{VcsFlightComponent.vue.d.ts → VcsFlightComponent.ts.vue.d.ts}

@@ -1,4 +1,21 @@
-declare const _default: import("vue").DefineComponent<{
+import { durationRule } from './VcsFlightAnchorsComponent.ts.vue';
+/**
+ * @description A component to model @vcmap/core/FlightInstanceOptions.
+ * Requires a flightInstance to be provided via vue-provide.
+ * If a reset functionality is required use shallowRef to provide the flightInstance.
+ * @vue-prop {string} heading - Title of flight settings.
+ * @vue-prop {boolean} [expandable] - Expandable sections.
+ * @vue-prop {boolean} hideName - Hide name input.
+ * @vue-prop {boolean} hideTitle - Hide title input.
+ * @vue-prop {boolean} hideInterpolation - Hide select interpolation input.
+ * @vue-prop {boolean} hideLoop - Hide loop input.
+ * @vue-prop {boolean} hideGeneral - Hide all general settings (name, title, animate).
+ * @vue-prop {string} [parentId] - id of the window, the VcsFlightComponent is used in
+ * @vue-prop {string} [owner] - owner of the window, e.g. a plugin name
+ */
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: import("vue", { with: { "resolution-mode": "import" } }).DefineComponent<{
     heading: {
         type: StringConstructor;
         default: string;
@@ -41,14 +58,14 @@ declare const _default: import("vue").DefineComponent<{
     };
 }, {
     name: string;
-    title: import("vue").WritableComputedRef<unknown>;
-    interpolation: import("vue").WritableComputedRef<import("@vcmap/core", { with: { "resolution-mode": "import" } }).FlightInterpolation>;
-    duration: import("vue").WritableComputedRef<number>;
+    title: import("vue", { with: { "resolution-mode": "import" } }).WritableComputedRef<string>;
+    interpolation: import("vue", { with: { "resolution-mode": "import" } }).WritableComputedRef<import("@vcmap/core", { with: { "resolution-mode": "import" } }).FlightInterpolation>;
+    duration: import("vue", { with: { "resolution-mode": "import" } }).WritableComputedRef<number>;
     durationRule: typeof durationRule;
-    loop: import("vue").WritableComputedRef<boolean>;
-    disablePlayer: import("vue").Ref<boolean>;
+    loop: import("vue", { with: { "resolution-mode": "import" } }).WritableComputedRef<boolean>;
+    disablePlayer: import("vue", { with: { "resolution-mode": "import" } }).Ref<boolean>;
     cid: string;
-}, any, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+}, 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<{
     heading: {
         type: StringConstructor;
         default: string;
@@ -90,16 +107,14 @@ declare const _default: import("vue").DefineComponent<{
         default: symbol;
     };
 }>>, {
-    owner: string | symbol;
-    parentId: string;
     heading: string;
     expandable: boolean;
     hideName: boolean;
     hideTitle: boolean;
     hideGeneral: boolean;
+    parentId: string;
+    owner: string | symbol;
     hideInterpolation: boolean;
     hideDuration: boolean;
     hideLoop: boolean;
 }, {}>;
-export default _default;
-import { durationRule } from './VcsFlightAnchorsComponent.vue';

package/src/components/flight/{VcsFlightEditor.vue → VcsFlightEditor.ts.vue}

@@ -7,25 +7,27 @@
     v-bind="{ ...$attrs, ...$props }"
   >
     <VcsFlightComponent
-      :parent-id="$attrs['window-state'].id"
+      :parent-id="parentId"
       v-bind="{ ...$attrs, ...$props }"
     />
   </AbstractConfigEditor>
 </template>
 
-<script>
-  import { onUnmounted, provide } from 'vue';
+<script lang="ts">
+  import { defineComponent, onUnmounted, provide } from 'vue';
+  import type { PropType } from 'vue';
   import { FlightInstance } from '@vcmap/core';
   import deepEqual from 'fast-deep-equal';
-  import AbstractConfigEditor from '../plugins/AbstractConfigEditor.vue';
-  import VcsFlightComponent from './VcsFlightComponent.vue';
+  import AbstractConfigEditor from '../plugins/AbstractConfigEditor.ts.vue';
+  import VcsFlightComponent from './VcsFlightComponent.ts.vue';
+  import type { WindowState } from '../../manager/window/windowManager.js';
 
   /**
    * An editor component for viewpoints using AbstractConfigEditor and VcsFlightComponent
    * @vue-prop {() => import("@vcmap/core").FlightInstance} getProvidedFlightInstance
-   * @vue-prop {(instance: import("@vcmap/core).FlightInstance) => Promise<void>} setFlightInstance
+   * @vue-prop {(instance: import("@vcmap/core").FlightInstance) => Promise<void>} setFlightInstance
    */
-  export default {
+  export default defineComponent({
     name: 'VcsFlightEditor',
     components: {
       AbstractConfigEditor,
@@ -33,47 +35,48 @@
     },
     props: {
       getFlightInstance: {
-        type: Function,
+        type: Function as PropType<() => FlightInstance>,
         required: true,
       },
       setFlightInstance: {
-        type: Function,
+        type: Function as PropType<(instance: FlightInstance) => Promise<void>>,
         required: true,
       },
       resetFlightInstance: {
-        type: Function,
-        default: () => {},
+        type: Function as PropType<(instance: FlightInstance) => Promise<void>>,
+        default: () => Promise.resolve(),
       },
     },
     emits: ['close'],
-    setup(props, { emit }) {
+    setup(props, { attrs, emit }) {
       const flightInstance = props.getFlightInstance();
       let cancel = false;
 
       const originalConfig = flightInstance.toJSON();
       provide('flightInstance', flightInstance);
 
-      onUnmounted(() => {
+      onUnmounted(async () => {
         if (!cancel && !deepEqual(originalConfig, flightInstance.toJSON())) {
-          props.setFlightInstance(flightInstance);
+          await props.setFlightInstance(flightInstance);
         }
       });
 
       return {
-        async apply() {
+        parentId: (attrs['window-state'] as WindowState).id,
+        apply(): void {
           emit('close');
         },
-        async cancel() {
+        async cancel(): Promise<void> {
           cancel = true;
           await props.resetFlightInstance(new FlightInstance(originalConfig));
           emit('close');
         },
-        async reset() {
+        async reset(): Promise<void> {
           await props.resetFlightInstance(new FlightInstance(originalConfig));
         },
       };
     },
-  };
+  });
 </script>
 
 <style scoped></style>

package/src/components/flight/VcsFlightEditor.ts.vue.d.ts

@@ -0,0 +1,45 @@
+import type { PropType } from 'vue';
+import { FlightInstance } from '@vcmap/core';
+/**
+ * An editor component for viewpoints using AbstractConfigEditor and VcsFlightComponent
+ * @vue-prop {() => import("@vcmap/core").FlightInstance} getProvidedFlightInstance
+ * @vue-prop {(instance: import("@vcmap/core").FlightInstance) => Promise<void>} setFlightInstance
+ */
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: import("vue", { with: { "resolution-mode": "import" } }).DefineComponent<{
+    getFlightInstance: {
+        type: PropType<() => FlightInstance>;
+        required: true;
+    };
+    setFlightInstance: {
+        type: PropType<(instance: FlightInstance) => Promise<void>>;
+        required: true;
+    };
+    resetFlightInstance: {
+        type: PropType<(instance: FlightInstance) => Promise<void>>;
+        default: () => Promise<void>;
+    };
+}, {
+    parentId: string;
+    apply(): void;
+    cancel(): Promise<void>;
+    reset(): Promise<void>;
+}, unknown, {}, {}, import("vue", { with: { "resolution-mode": "import" } }).ComponentOptionsMixin, import("vue", { with: { "resolution-mode": "import" } }).ComponentOptionsMixin, "close"[], "close", import("vue", { with: { "resolution-mode": "import" } }).PublicProps, Readonly<import("vue", { with: { "resolution-mode": "import" } }).ExtractPropTypes<{
+    getFlightInstance: {
+        type: PropType<() => FlightInstance>;
+        required: true;
+    };
+    setFlightInstance: {
+        type: PropType<(instance: FlightInstance) => Promise<void>>;
+        required: true;
+    };
+    resetFlightInstance: {
+        type: PropType<(instance: FlightInstance) => Promise<void>>;
+        default: () => Promise<void>;
+    };
+}>> & {
+    onClose?: ((...args: any[]) => any) | undefined;
+}, {
+    resetFlightInstance: (instance: FlightInstance) => Promise<void>;
+}, {}>;

package/src/components/flight/{VcsFlightPlayer.vue → VcsFlightPlayer.ts.vue}

@@ -1,7 +1,7 @@
 <template>
   <v-container class="py-0 px-1 vcs-flight-player">
     <v-row no-gutters class="d-flex align-center">
-      <VcsLabel html-for="player">{{ $t('flight.player') }}</VcsLabel>
+      <VcsLabel html-for="player">{{ $st('flight.player') }}</VcsLabel>
       <v-row class="d-flex justify-end px-1 gc-2" no-gutters>
         <VcsActionButtonList
           overflow-icon="$vcsShare"
@@ -42,41 +42,48 @@
   </v-container>
 </template>
 
-<script>
-  import { inject, onMounted, onUnmounted, ref } from 'vue';
+<script lang="ts">
+  import type { Ref } from 'vue';
+  import { defineComponent, inject, onMounted, onUnmounted, ref } from 'vue';
   import { VContainer, VRow } from 'vuetify/components';
-  import VcsSlider from '../form-inputs-controls/VcsSlider.vue';
-  import VcsLabel from '../form-inputs-controls/VcsLabel.vue';
-  import VcsButton from '../buttons/VcsButton.vue';
-  import VcsActionButtonList from '../buttons/VcsActionButtonList.vue';
+  import type { FlightPlayer, FlightPlayerClock } from '@vcmap/core';
+  import VcsSlider from '../form-inputs-controls/VcsSlider.ts.vue';
+  import VcsLabel from '../form-inputs-controls/VcsLabel.ts.vue';
+  import VcsButton from '../buttons/VcsButton.ts.vue';
+  import VcsActionButtonList from '../buttons/VcsActionButtonList.ts.vue';
   import {
     createFlightMovieActions,
     createFlightPlayerActions,
   } from '../../actions/flightActions.js';
   import { getProvidedFlightInstance } from './composables.js';
+  import type VcsUiApp from '../../vcsUiApp.js';
 
-  function getDefaultClock() {
-    return { startTime: 0, endTime: 0, currentTime: 0, times: [] };
+  type Writable<T> = { -readonly [K in keyof T]: T[K] };
+  type FlightClockState = Writable<
+    Pick<FlightPlayerClock, 'startTime' | 'endTime' | 'currentTime'>
+  >;
+  function getDefaultClock(): FlightClockState {
+    return { startTime: 0, endTime: 0, currentTime: 0 };
   }
 
-  /**
-   *
-   * @param {import("vue").Ref<Partial<import("@vcmap/core").FlightPlayerClock>>} clock
-   * @param {import("@vcmap/core").FlightPlayerClock} changed
-   */
-  function syncClocks(clock, changed) {
-    Object.keys(getDefaultClock()).forEach((key) => {
-      if (clock.value[key] !== changed[key]) {
-        clock.value[key] = changed[key];
-      }
-    });
+  function syncClocks(
+    clock: Ref<FlightClockState>,
+    changed: FlightClockState,
+  ): void {
+    (Object.keys(getDefaultClock()) as Array<keyof FlightClockState>).forEach(
+      (key) => {
+        if (clock.value[key] !== changed[key]) {
+          clock.value[key] = changed[key];
+        }
+      },
+    );
   }
 
   /**
    * @description A component for editing flight anchors.
    * Requires a flightInstance to be provided via vue-provide.
    */
-  export default {
+  export default defineComponent({
     name: 'VcsFlightPlayer',
     components: {
       VContainer,
@@ -88,24 +95,21 @@
     },
     props: { disabled: { type: Boolean, default: false } },
     setup() {
-      /**
-       * @type {import("../../vcsUiApp.js").default}
-       */
-      const app = inject('vcsApp');
+      const app = inject('vcsApp') as VcsUiApp;
       const flightInstance = getProvidedFlightInstance();
-      const clock = ref(getDefaultClock());
+      const clock = ref<FlightClockState>(getDefaultClock());
       const isCurrentPlayer = ref(true);
-      let flightInstancePlayer;
+      let flightInstancePlayer: FlightPlayer | undefined;
 
       const { actions, destroy } = createFlightPlayerActions(
         app,
         flightInstance,
       );
 
-      let clockChangedListener = () => {};
-      let playerChangedListener = () => {};
+      let clockChangedListener = (): void => {};
+      let playerChangedListener = (): void => {};
 
-      function syncPlayer(player) {
+      function syncPlayer(player: FlightPlayer | undefined): void {
         if (player?.flightInstanceName === flightInstance.name) {
           isCurrentPlayer.value = true;
           flightInstancePlayer = player;
@@ -129,7 +133,7 @@
         flightInstancePlayer =
           await app.flights.setPlayerForFlight(flightInstance);
         syncPlayer(flightInstancePlayer);
-        syncClocks(clock, flightInstancePlayer.clock);
+        syncClocks(clock, flightInstancePlayer!.clock);
         playerChangedListener = app.flights.playerChanged.addEventListener(
           (player) => {
             clockChangedListener();
@@ -149,17 +153,18 @@
         actions,
         isCurrentPlayer,
         recordingActions,
-        clockTime(seconds) {
+        clockTime(seconds: number): string {
           const mins = Math.floor(seconds / 60);
           const secs = Math.floor(seconds % 60);
           return `${mins}:${secs < 10 ? 0 : ''}${secs}`;
         },
-        setTime(seconds) {
+        setTime(seconds: number): void {
           clock.value.currentTime = seconds;
           flightInstancePlayer?.goToTime(seconds);
         },
       };
     },
-  };
+  });
 </script>
+
 <style scoped lang="scss"></style>

package/src/components/flight/VcsFlightPlayer.ts.vue.d.ts

@@ -0,0 +1,31 @@
+import type { Ref } from 'vue';
+/**
+ * @description A component for editing flight anchors.
+ * Requires a flightInstance to be provided via vue-provide.
+ */
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: import("vue", { with: { "resolution-mode": "import" } }).DefineComponent<{
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}, {
+    clock: Ref<{
+        startTime: number;
+        endTime: number;
+        currentTime: number;
+    }>;
+    actions: action[];
+    isCurrentPlayer: Ref<boolean>;
+    recordingActions: import("../../actions/actionHelper.js", { with: { "resolution-mode": "import" } }).VcsAction[];
+    clockTime(seconds: number): string;
+    setTime(seconds: number): void;
+}, 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<{
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>>, {
+    disabled: boolean;
+}, {}>;

package/src/components/flight/composables.d.ts

@@ -1,11 +1,9 @@
+import type { FlightInstance } from '@vcmap/core';
+import type { Ref } from 'vue';
+import type WindowManager from '../../manager/window/windowManager.js';
 /**
  * Unwraps the FlightInstance, if a shallowRef is provided
  * @returns {import("@vcmap/core").FlightInstance}
  */
-export function getProvidedFlightInstance(): import("@vcmap/core").FlightInstance;
-/**
- * @param {import("../../manager/window/windowManager.js").default} windowManager
- * @param {import("vue").Ref<boolean>} disabled
- * @returns {(function(): void)}
- */
-export function setupFlightAnchorEditingListener(windowManager: import("../../manager/window/windowManager.js").default, disabled: import("vue").Ref<boolean>): (() => void);
+export declare function getProvidedFlightInstance(): FlightInstance;
+export declare function setupFlightAnchorEditingListener(windowManager: WindowManager, disabled: Ref<boolean>): () => void;

package/src/components/flight/{composables.js → composables.ts}

@@ -1,24 +1,27 @@
+import type { FlightInstance } from '@vcmap/core';
+import type { Ref } from 'vue';
 import { inject, isRef, unref } from 'vue';
-import VcsViewpointEditor from '../viewpoint/VcsViewpointEditor.vue';
+import VcsViewpointEditor from '../viewpoint/VcsViewpointEditor.ts.vue';
+import type WindowManager from '../../manager/window/windowManager.js';
 
 /**
  * Unwraps the FlightInstance, if a shallowRef is provided
  * @returns {import("@vcmap/core").FlightInstance}
  */
-export function getProvidedFlightInstance() {
-  const injected = inject('flightInstance');
+export function getProvidedFlightInstance(): FlightInstance {
+  const injected = inject('flightInstance') as
+    | FlightInstance
+    | Ref<FlightInstance>;
   if (isRef(injected)) {
     return unref(injected);
   }
   return injected;
 }
 
-/**
- * @param {import("../../manager/window/windowManager.js").default} windowManager
- * @param {import("vue").Ref<boolean>} disabled
- * @returns {(function(): void)}
- */
-export function setupFlightAnchorEditingListener(windowManager, disabled) {
+export function setupFlightAnchorEditingListener(
+  windowManager: WindowManager,
+  disabled: Ref<boolean>,
+): () => void {
   const editingAnchors = new Set();
   const anchorEditorListeners = [
     windowManager.added.addEventListener((added) => {
@@ -34,6 +37,8 @@ export function setupFlightAnchorEditingListener(windowManager, disabled) {
     }),
   ];
   return () => {
-    anchorEditorListeners.forEach((cb) => cb());
+    anchorEditorListeners.forEach((cb) => {
+      cb();
+    });
   };
 }