Tracking de l'application VApp (IHM du jeu)

VApp/node_modules/vuetify/lib/components/VWindow/VWindow.css

@@ -0,0 +1,70 @@
+.v-window {
+  overflow: hidden;
+}
+.v-window__container {
+  display: flex;
+  flex-direction: column;
+  height: inherit;
+  position: relative;
+  transition: 0.3s cubic-bezier(0.25, 0.8, 0.5, 1);
+}
+.v-window__controls {
+  position: absolute;
+  left: 0;
+  top: 0;
+  width: 100%;
+  height: 100%;
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  padding: 0 16px;
+  pointer-events: none;
+}
+.v-window__controls > * {
+  pointer-events: auto;
+}
+.v-window--show-arrows-on-hover {
+  overflow: hidden;
+}
+.v-window--show-arrows-on-hover .v-window__left {
+  transform: translateX(-200%);
+}
+.v-window--show-arrows-on-hover .v-window__right {
+  transform: translateX(200%);
+}
+.v-window--show-arrows-on-hover:hover .v-window__left,
+.v-window--show-arrows-on-hover:hover .v-window__right {
+  transform: translateX(0);
+}
+.v-window-x-transition-enter-active, .v-window-x-transition-leave-active, .v-window-x-reverse-transition-enter-active, .v-window-x-reverse-transition-leave-active, .v-window-y-transition-enter-active, .v-window-y-transition-leave-active, .v-window-y-reverse-transition-enter-active, .v-window-y-reverse-transition-leave-active {
+  transition: 0.3s cubic-bezier(0.25, 0.8, 0.5, 1);
+}
+.v-window-x-transition-leave-from, .v-window-x-transition-leave-to, .v-window-x-reverse-transition-leave-from, .v-window-x-reverse-transition-leave-to, .v-window-y-transition-leave-from, .v-window-y-transition-leave-to, .v-window-y-reverse-transition-leave-from, .v-window-y-reverse-transition-leave-to {
+  position: absolute !important;
+  top: 0;
+  width: 100%;
+}
+.v-window-x-transition-enter-from {
+  transform: translateX(100%);
+}
+.v-window-x-transition-leave-to {
+  transform: translateX(-100%);
+}
+.v-window-x-reverse-transition-enter-from {
+  transform: translateX(-100%);
+}
+.v-window-x-reverse-transition-leave-to {
+  transform: translateX(100%);
+}
+.v-window-y-transition-enter-from {
+  transform: translateY(100%);
+}
+.v-window-y-transition-leave-to {
+  transform: translateY(-100%);
+}
+.v-window-y-reverse-transition-enter-from {
+  transform: translateY(-100%);
+}
+.v-window-y-reverse-transition-leave-to {
+  transform: translateY(100%);
+}

VApp/node_modules/vuetify/lib/components/VWindow/VWindow.mjs

@@ -0,0 +1,188 @@
+import { withDirectives as _withDirectives, resolveDirective as _resolveDirective, createVNode as _createVNode } from "vue";
+// Styles
+import "./VWindow.css";
+
+// Components
+import { VBtn } from "../VBtn/index.mjs"; // Composables
+import { makeComponentProps } from "../../composables/component.mjs";
+import { useGroup } from "../../composables/group.mjs";
+import { useLocale, useRtl } from "../../composables/locale.mjs";
+import { makeTagProps } from "../../composables/tag.mjs";
+import { makeThemeProps, provideTheme } from "../../composables/theme.mjs"; // Directives
+import { Touch } from "../../directives/touch/index.mjs"; // Utilities
+import { computed, provide, ref, shallowRef, watch } from 'vue';
+import { genericComponent, propsFactory, useRender } from "../../util/index.mjs"; // Types
+export const VWindowSymbol = Symbol.for('vuetify:v-window');
+export const VWindowGroupSymbol = Symbol.for('vuetify:v-window-group');
+export const makeVWindowProps = propsFactory({
+  continuous: Boolean,
+  nextIcon: {
+    type: [Boolean, String, Function, Object],
+    default: '$next'
+  },
+  prevIcon: {
+    type: [Boolean, String, Function, Object],
+    default: '$prev'
+  },
+  reverse: Boolean,
+  showArrows: {
+    type: [Boolean, String],
+    validator: v => typeof v === 'boolean' || v === 'hover'
+  },
+  touch: {
+    type: [Object, Boolean],
+    default: undefined
+  },
+  direction: {
+    type: String,
+    default: 'horizontal'
+  },
+  modelValue: null,
+  disabled: Boolean,
+  selectedClass: {
+    type: String,
+    default: 'v-window-item--active'
+  },
+  // TODO: mandatory should probably not be exposed but do this for now
+  mandatory: {
+    type: [Boolean, String],
+    default: 'force'
+  },
+  ...makeComponentProps(),
+  ...makeTagProps(),
+  ...makeThemeProps()
+}, 'VWindow');
+export const VWindow = genericComponent()({
+  name: 'VWindow',
+  directives: {
+    Touch
+  },
+  props: makeVWindowProps(),
+  emits: {
+    'update:modelValue': value => true
+  },
+  setup(props, _ref) {
+    let {
+      slots
+    } = _ref;
+    const {
+      themeClasses
+    } = provideTheme(props);
+    const {
+      isRtl
+    } = useRtl();
+    const {
+      t
+    } = useLocale();
+    const group = useGroup(props, VWindowGroupSymbol);
+    const rootRef = ref();
+    const isRtlReverse = computed(() => isRtl.value ? !props.reverse : props.reverse);
+    const isReversed = shallowRef(false);
+    const transition = computed(() => {
+      const axis = props.direction === 'vertical' ? 'y' : 'x';
+      const reverse = isRtlReverse.value ? !isReversed.value : isReversed.value;
+      const direction = reverse ? '-reverse' : '';
+      return `v-window-${axis}${direction}-transition`;
+    });
+    const transitionCount = shallowRef(0);
+    const transitionHeight = ref(undefined);
+    const activeIndex = computed(() => {
+      return group.items.value.findIndex(item => group.selected.value.includes(item.id));
+    });
+    watch(activeIndex, (newVal, oldVal) => {
+      const itemsLength = group.items.value.length;
+      const lastIndex = itemsLength - 1;
+      if (itemsLength <= 2) {
+        isReversed.value = newVal < oldVal;
+      } else if (newVal === lastIndex && oldVal === 0) {
+        isReversed.value = true;
+      } else if (newVal === 0 && oldVal === lastIndex) {
+        isReversed.value = false;
+      } else {
+        isReversed.value = newVal < oldVal;
+      }
+    });
+    provide(VWindowSymbol, {
+      transition,
+      isReversed,
+      transitionCount,
+      transitionHeight,
+      rootRef
+    });
+    const canMoveBack = computed(() => props.continuous || activeIndex.value !== 0);
+    const canMoveForward = computed(() => props.continuous || activeIndex.value !== group.items.value.length - 1);
+    function prev() {
+      canMoveBack.value && group.prev();
+    }
+    function next() {
+      canMoveForward.value && group.next();
+    }
+    const arrows = computed(() => {
+      const arrows = [];
+      const prevProps = {
+        icon: isRtl.value ? props.nextIcon : props.prevIcon,
+        class: `v-window__${isRtlReverse.value ? 'right' : 'left'}`,
+        onClick: group.prev,
+        'aria-label': t('$vuetify.carousel.prev')
+      };
+      arrows.push(canMoveBack.value ? slots.prev ? slots.prev({
+        props: prevProps
+      }) : _createVNode(VBtn, prevProps, null) : _createVNode("div", null, null));
+      const nextProps = {
+        icon: isRtl.value ? props.prevIcon : props.nextIcon,
+        class: `v-window__${isRtlReverse.value ? 'left' : 'right'}`,
+        onClick: group.next,
+        'aria-label': t('$vuetify.carousel.next')
+      };
+      arrows.push(canMoveForward.value ? slots.next ? slots.next({
+        props: nextProps
+      }) : _createVNode(VBtn, nextProps, null) : _createVNode("div", null, null));
+      return arrows;
+    });
+    const touchOptions = computed(() => {
+      if (props.touch === false) return props.touch;
+      const options = {
+        left: () => {
+          isRtlReverse.value ? prev() : next();
+        },
+        right: () => {
+          isRtlReverse.value ? next() : prev();
+        },
+        start: _ref2 => {
+          let {
+            originalEvent
+          } = _ref2;
+          originalEvent.stopPropagation();
+        }
+      };
+      return {
+        ...options,
+        ...(props.touch === true ? {} : props.touch)
+      };
+    });
+    useRender(() => _withDirectives(_createVNode(props.tag, {
+      "ref": rootRef,
+      "class": ['v-window', {
+        'v-window--show-arrows-on-hover': props.showArrows === 'hover'
+      }, themeClasses.value, props.class],
+      "style": props.style
+    }, {
+      default: () => [_createVNode("div", {
+        "class": "v-window__container",
+        "style": {
+          height: transitionHeight.value
+        }
+      }, [slots.default?.({
+        group
+      }), props.showArrows !== false && _createVNode("div", {
+        "class": "v-window__controls"
+      }, [arrows.value])]), slots.additional?.({
+        group
+      })]
+    }), [[_resolveDirective("touch"), touchOptions.value]]));
+    return {
+      group
+    };
+  }
+});
+//# sourceMappingURL=VWindow.mjs.map

VApp/node_modules/vuetify/lib/components/VWindow/VWindow.sass

@@ -0,0 +1,82 @@
+@use './variables' as *
+
+.v-window
+  overflow: hidden
+
+  &__container
+    display: flex
+    flex-direction: column
+    height: inherit
+    position: relative
+    transition: $window-transition
+
+  &__controls
+    position: absolute
+    left: 0
+    top: 0
+    width: 100%
+    height: 100%
+    display: flex
+    align-items: center
+    justify-content: space-between
+    padding: $window-controls-padding
+    pointer-events: none
+
+    > *
+      pointer-events: auto
+
+  &--show-arrows-on-hover
+    overflow: hidden
+
+    .v-window__left
+      transform: translateX(-200%)
+
+    .v-window__right
+      transform: translateX(200%)
+
+    &:hover
+      .v-window__left,
+      .v-window__right
+        transform: translateX(0)
+
+  &-x-transition,
+  &-x-reverse-transition,
+  &-y-transition,
+  &-y-reverse-transition
+    &-enter-active,
+    &-leave-active
+      transition: $window-transition
+
+    &-leave-from,
+    &-leave-to
+      position: absolute !important
+      top: 0
+      width: 100%
+
+  &-x-transition
+    &-enter-from
+      transform: translateX(100%)
+
+    &-leave-to
+      transform: translateX(-100%)
+
+  &-x-reverse-transition
+    &-enter-from
+      transform: translateX(-100%)
+
+    &-leave-to
+      transform: translateX(100%)
+
+  &-y-transition
+    &-enter-from
+      transform: translateY(100%)
+
+    &-leave-to
+      transform: translateY(-100%)
+
+  &-y-reverse-transition
+    &-enter-from
+      transform: translateY(-100%)
+
+    &-leave-to
+      transform: translateY(100%)

VApp/node_modules/vuetify/lib/components/VWindow/VWindowItem.mjs

@@ -0,0 +1,122 @@
+import { withDirectives as _withDirectives, createVNode as _createVNode, vShow as _vShow } from "vue";
+// Composables
+import { makeComponentProps } from "../../composables/component.mjs";
+import { makeGroupItemProps, useGroupItem } from "../../composables/group.mjs";
+import { makeLazyProps, useLazy } from "../../composables/lazy.mjs";
+import { useSsrBoot } from "../../composables/ssrBoot.mjs";
+import { MaybeTransition } from "../../composables/transition.mjs"; // Directives
+import Touch from "../../directives/touch/index.mjs"; // Utilities
+import { computed, inject, nextTick, shallowRef } from 'vue';
+import { convertToUnit, genericComponent, propsFactory, useRender } from "../../util/index.mjs"; // Types
+import { VWindowGroupSymbol, VWindowSymbol } from "./VWindow.mjs";
+export const makeVWindowItemProps = propsFactory({
+  reverseTransition: {
+    type: [Boolean, String],
+    default: undefined
+  },
+  transition: {
+    type: [Boolean, String],
+    default: undefined
+  },
+  ...makeComponentProps(),
+  ...makeGroupItemProps(),
+  ...makeLazyProps()
+}, 'VWindowItem');
+export const VWindowItem = genericComponent()({
+  name: 'VWindowItem',
+  directives: {
+    Touch
+  },
+  props: makeVWindowItemProps(),
+  emits: {
+    'group:selected': val => true
+  },
+  setup(props, _ref) {
+    let {
+      slots
+    } = _ref;
+    const window = inject(VWindowSymbol);
+    const groupItem = useGroupItem(props, VWindowGroupSymbol);
+    const {
+      isBooted
+    } = useSsrBoot();
+    if (!window || !groupItem) throw new Error('[Vuetify] VWindowItem must be used inside VWindow');
+    const isTransitioning = shallowRef(false);
+    const hasTransition = computed(() => isBooted.value && (window.isReversed.value ? props.reverseTransition !== false : props.transition !== false));
+    function onAfterTransition() {
+      if (!isTransitioning.value || !window) {
+        return;
+      }
+
+      // Finalize transition state.
+      isTransitioning.value = false;
+      if (window.transitionCount.value > 0) {
+        window.transitionCount.value -= 1;
+
+        // Remove container height if we are out of transition.
+        if (window.transitionCount.value === 0) {
+          window.transitionHeight.value = undefined;
+        }
+      }
+    }
+    function onBeforeTransition() {
+      if (isTransitioning.value || !window) {
+        return;
+      }
+
+      // Initialize transition state here.
+      isTransitioning.value = true;
+      if (window.transitionCount.value === 0) {
+        // Set initial height for height transition.
+        window.transitionHeight.value = convertToUnit(window.rootRef.value?.clientHeight);
+      }
+      window.transitionCount.value += 1;
+    }
+    function onTransitionCancelled() {
+      onAfterTransition(); // This should have the same path as normal transition end.
+    }
+    function onEnterTransition(el) {
+      if (!isTransitioning.value) {
+        return;
+      }
+      nextTick(() => {
+        // Do not set height if no transition or cancelled.
+        if (!hasTransition.value || !isTransitioning.value || !window) {
+          return;
+        }
+
+        // Set transition target height.
+        window.transitionHeight.value = convertToUnit(el.clientHeight);
+      });
+    }
+    const transition = computed(() => {
+      const name = window.isReversed.value ? props.reverseTransition : props.transition;
+      return !hasTransition.value ? false : {
+        name: typeof name !== 'string' ? window.transition.value : name,
+        onBeforeEnter: onBeforeTransition,
+        onAfterEnter: onAfterTransition,
+        onEnterCancelled: onTransitionCancelled,
+        onBeforeLeave: onBeforeTransition,
+        onAfterLeave: onAfterTransition,
+        onLeaveCancelled: onTransitionCancelled,
+        onEnter: onEnterTransition
+      };
+    });
+    const {
+      hasContent
+    } = useLazy(props, groupItem.isSelected);
+    useRender(() => _createVNode(MaybeTransition, {
+      "transition": transition.value,
+      "disabled": !isBooted.value
+    }, {
+      default: () => [_withDirectives(_createVNode("div", {
+        "class": ['v-window-item', groupItem.selectedClass.value, props.class],
+        "style": props.style
+      }, [hasContent.value && slots.default?.()]), [[_vShow, groupItem.isSelected.value]])]
+    }));
+    return {
+      groupItem
+    };
+  }
+});
+//# sourceMappingURL=VWindowItem.mjs.map

VApp/node_modules/vuetify/lib/components/VWindow/_variables.scss

@@ -0,0 +1,5 @@
+@use '../../styles/settings';
+
+// VWindow
+$window-transition: .3s cubic-bezier(.25, .8, .50, 1) !default;
+$window-controls-padding: 0 16px !default;

VApp/node_modules/vuetify/lib/components/VWindow/index.d.mts

@@ -0,0 +1,557 @@
+import * as vue from 'vue';
+import { ComponentPropsOptions, ExtractPropTypes, VNodeChild, VNode, ComponentInternalInstance, Ref, ComputedRef, JSXComponent, PropType } from 'vue';
+
+type SlotsToProps<U extends RawSlots, T = MakeInternalSlots<U>> = {
+    $children?: (VNodeChild | (T extends {
+        default: infer V;
+    } ? V : {}) | {
+        [K in keyof T]?: T[K];
+    });
+    'v-slots'?: {
+        [K in keyof T]?: T[K] | false;
+    };
+} & {
+    [K in keyof T as `v-slot:${K & string}`]?: T[K] | false;
+};
+type RawSlots = Record<string, unknown>;
+type Slot<T> = [T] extends [never] ? () => VNodeChild : (arg: T) => VNodeChild;
+type VueSlot<T> = [T] extends [never] ? () => VNode[] : (arg: T) => VNode[];
+type MakeInternalSlots<T extends RawSlots> = {
+    [K in keyof T]: Slot<T[K]>;
+};
+type MakeSlots<T extends RawSlots> = {
+    [K in keyof T]: VueSlot<T[K]>;
+};
+type GenericProps<Props, Slots extends Record<string, unknown>> = {
+    $props: Props & SlotsToProps<Slots>;
+    $slots: MakeSlots<Slots>;
+};
+interface FilterPropsOptions<PropsOptions extends Readonly<ComponentPropsOptions>, Props = ExtractPropTypes<PropsOptions>> {
+    filterProps<T extends Partial<Props>, U extends Exclude<keyof Props, Exclude<keyof Props, keyof T>>>(props: T): Partial<Pick<T, U>>;
+}
+
+interface GroupItem {
+    id: number;
+    value: Ref<unknown>;
+    disabled: Ref<boolean | undefined>;
+}
+interface GroupProvide {
+    register: (item: GroupItem, cmp: ComponentInternalInstance) => void;
+    unregister: (id: number) => void;
+    select: (id: number, value: boolean) => void;
+    selected: Ref<Readonly<number[]>>;
+    isSelected: (id: number) => boolean;
+    prev: () => void;
+    next: () => void;
+    selectedClass: Ref<string | undefined>;
+    items: ComputedRef<{
+        id: number;
+        value: unknown;
+        disabled: boolean | undefined;
+    }[]>;
+    disabled: Ref<boolean | undefined>;
+    getItemIndex: (value: unknown) => number;
+}
+interface GroupItemProvide {
+    id: number;
+    isSelected: Ref<boolean>;
+    toggle: () => void;
+    select: (value: boolean) => void;
+    selectedClass: Ref<(string | undefined)[] | false>;
+    value: Ref<unknown>;
+    disabled: Ref<boolean | undefined>;
+    group: GroupProvide;
+}
+
+type IconValue = string | (string | [path: string, opacity: number])[] | JSXComponent;
+declare const IconValue: PropType<IconValue>;
+
+interface TouchHandlers {
+    start?: (wrapperEvent: {
+        originalEvent: TouchEvent;
+    } & TouchData) => void;
+    end?: (wrapperEvent: {
+        originalEvent: TouchEvent;
+    } & TouchData) => void;
+    move?: (wrapperEvent: {
+        originalEvent: TouchEvent;
+    } & TouchData) => void;
+    left?: (wrapper: TouchData) => void;
+    right?: (wrapper: TouchData) => void;
+    up?: (wrapper: TouchData) => void;
+    down?: (wrapper: TouchData) => void;
+}
+interface TouchData {
+    touchstartX: number;
+    touchstartY: number;
+    touchmoveX: number;
+    touchmoveY: number;
+    touchendX: number;
+    touchendY: number;
+    offsetX: number;
+    offsetY: number;
+}
+
+type VWindowSlots = {
+    default: {
+        group: GroupProvide;
+    };
+    additional: {
+        group: GroupProvide;
+    };
+    prev: {
+        props: ControlProps;
+    };
+    next: {
+        props: ControlProps;
+    };
+};
+type ControlProps = {
+    icon: IconValue;
+    class: string;
+    onClick: () => void;
+    'aria-label': string;
+};
+declare const VWindow: {
+    new (...args: any[]): vue.CreateComponentPublicInstance<{
+        reverse: boolean;
+        direction: "horizontal" | "vertical";
+        style: vue.StyleValue;
+        disabled: boolean;
+        tag: string;
+        mandatory: boolean | "force";
+        selectedClass: string;
+        nextIcon: IconValue;
+        prevIcon: IconValue;
+        continuous: boolean;
+    } & {
+        class?: any;
+        touch?: boolean | TouchHandlers | undefined;
+        theme?: string | undefined;
+        showArrows?: string | boolean | undefined;
+    } & {}, {
+        group: GroupProvide;
+    }, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Omit<{
+        'update:modelValue': (value: any) => boolean;
+    }, "$children" | "v-slot:default" | "v-slots" | "v-slot:additional" | "modelValue" | "update:modelValue" | "v-slot:next" | "v-slot:prev">, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & {
+        reverse: boolean;
+        direction: "horizontal" | "vertical";
+        style: vue.StyleValue;
+        disabled: boolean;
+        tag: string;
+        mandatory: boolean | "force";
+        selectedClass: string;
+        nextIcon: IconValue;
+        prevIcon: IconValue;
+        continuous: boolean;
+    } & {
+        class?: any;
+        touch?: boolean | TouchHandlers | undefined;
+        theme?: string | undefined;
+        showArrows?: string | boolean | undefined;
+    } & {}, {
+        reverse: boolean;
+        direction: "horizontal" | "vertical";
+        style: vue.StyleValue;
+        disabled: boolean;
+        tag: string;
+        mandatory: boolean | "force";
+        touch: boolean | TouchHandlers;
+        selectedClass: string;
+        nextIcon: IconValue;
+        prevIcon: IconValue;
+        continuous: boolean;
+    }, true, {}, vue.SlotsType<Partial<{
+        default: (arg: {
+            group: GroupProvide;
+        }) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+            [key: string]: any;
+        }>[];
+        additional: (arg: {
+            group: GroupProvide;
+        }) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+            [key: string]: any;
+        }>[];
+        prev: (arg: {
+            props: ControlProps;
+        }) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+            [key: string]: any;
+        }>[];
+        next: (arg: {
+            props: ControlProps;
+        }) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+            [key: string]: any;
+        }>[];
+    }>>, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, {
+        reverse: boolean;
+        direction: "horizontal" | "vertical";
+        style: vue.StyleValue;
+        disabled: boolean;
+        tag: string;
+        mandatory: boolean | "force";
+        selectedClass: string;
+        nextIcon: IconValue;
+        prevIcon: IconValue;
+        continuous: boolean;
+    } & {
+        class?: any;
+        touch?: boolean | TouchHandlers | undefined;
+        theme?: string | undefined;
+        showArrows?: string | boolean | undefined;
+    } & {}, {
+        group: GroupProvide;
+    }, {}, {}, {}, {
+        reverse: boolean;
+        direction: "horizontal" | "vertical";
+        style: vue.StyleValue;
+        disabled: boolean;
+        tag: string;
+        mandatory: boolean | "force";
+        touch: boolean | TouchHandlers;
+        selectedClass: string;
+        nextIcon: IconValue;
+        prevIcon: IconValue;
+        continuous: boolean;
+    }>;
+    __isFragment?: undefined;
+    __isTeleport?: undefined;
+    __isSuspense?: undefined;
+} & vue.ComponentOptionsBase<{
+    reverse: boolean;
+    direction: "horizontal" | "vertical";
+    style: vue.StyleValue;
+    disabled: boolean;
+    tag: string;
+    mandatory: boolean | "force";
+    selectedClass: string;
+    nextIcon: IconValue;
+    prevIcon: IconValue;
+    continuous: boolean;
+} & {
+    class?: any;
+    touch?: boolean | TouchHandlers | undefined;
+    theme?: string | undefined;
+    showArrows?: string | boolean | undefined;
+} & {}, {
+    group: GroupProvide;
+}, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Omit<{
+    'update:modelValue': (value: any) => boolean;
+}, "$children" | "v-slot:default" | "v-slots" | "v-slot:additional" | "modelValue" | "update:modelValue" | "v-slot:next" | "v-slot:prev">, string, {
+    reverse: boolean;
+    direction: "horizontal" | "vertical";
+    style: vue.StyleValue;
+    disabled: boolean;
+    tag: string;
+    mandatory: boolean | "force";
+    touch: boolean | TouchHandlers;
+    selectedClass: string;
+    nextIcon: IconValue;
+    prevIcon: IconValue;
+    continuous: boolean;
+}, {}, string, vue.SlotsType<Partial<{
+    default: (arg: {
+        group: GroupProvide;
+    }) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+        [key: string]: any;
+    }>[];
+    additional: (arg: {
+        group: GroupProvide;
+    }) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+        [key: string]: any;
+    }>[];
+    prev: (arg: {
+        props: ControlProps;
+    }) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+        [key: string]: any;
+    }>[];
+    next: (arg: {
+        props: ControlProps;
+    }) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+        [key: string]: any;
+    }>[];
+}>>> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & (new <T>(props: {
+    modelValue?: T | undefined;
+    'onUpdate:modelValue'?: ((value: T) => void) | undefined;
+}, slots: VWindowSlots) => GenericProps<{
+    modelValue?: T | undefined;
+    'onUpdate:modelValue'?: ((value: T) => void) | undefined;
+}, VWindowSlots>) & FilterPropsOptions<{
+    theme: StringConstructor;
+    tag: {
+        type: StringConstructor;
+        default: string;
+    };
+    class: PropType<any>;
+    style: {
+        type: PropType<vue.StyleValue>;
+        default: null;
+    };
+    continuous: BooleanConstructor;
+    nextIcon: {
+        type: PropType<IconValue>;
+        default: string;
+    };
+    prevIcon: {
+        type: PropType<IconValue>;
+        default: string;
+    };
+    reverse: BooleanConstructor;
+    showArrows: {
+        type: (StringConstructor | BooleanConstructor)[];
+        validator: (v: any) => boolean;
+    };
+    touch: {
+        type: PropType<boolean | TouchHandlers>;
+        default: undefined;
+    };
+    direction: {
+        type: PropType<"horizontal" | "vertical">;
+        default: string;
+    };
+    modelValue: null;
+    disabled: BooleanConstructor;
+    selectedClass: {
+        type: StringConstructor;
+        default: string;
+    };
+    mandatory: {
+        type: PropType<boolean | "force">;
+        default: "force";
+    };
+}, vue.ExtractPropTypes<{
+    theme: StringConstructor;
+    tag: {
+        type: StringConstructor;
+        default: string;
+    };
+    class: PropType<any>;
+    style: {
+        type: PropType<vue.StyleValue>;
+        default: null;
+    };
+    continuous: BooleanConstructor;
+    nextIcon: {
+        type: PropType<IconValue>;
+        default: string;
+    };
+    prevIcon: {
+        type: PropType<IconValue>;
+        default: string;
+    };
+    reverse: BooleanConstructor;
+    showArrows: {
+        type: (StringConstructor | BooleanConstructor)[];
+        validator: (v: any) => boolean;
+    };
+    touch: {
+        type: PropType<boolean | TouchHandlers>;
+        default: undefined;
+    };
+    direction: {
+        type: PropType<"horizontal" | "vertical">;
+        default: string;
+    };
+    modelValue: null;
+    disabled: BooleanConstructor;
+    selectedClass: {
+        type: StringConstructor;
+        default: string;
+    };
+    mandatory: {
+        type: PropType<boolean | "force">;
+        default: "force";
+    };
+}>>;
+type VWindow = InstanceType<typeof VWindow>;
+
+declare const VWindowItem: {
+    new (...args: any[]): vue.CreateComponentPublicInstance<{
+        style: vue.StyleValue;
+        eager: boolean;
+        disabled: boolean;
+    } & {
+        transition?: string | boolean | undefined;
+        value?: any;
+        class?: any;
+        selectedClass?: string | undefined;
+        reverseTransition?: string | boolean | undefined;
+    } & {
+        $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
+            default?: (() => vue.VNodeChild) | undefined;
+        };
+        'v-slots'?: {
+            default?: false | (() => vue.VNodeChild) | undefined;
+        } | undefined;
+    } & {
+        "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
+    } & {
+        "onGroup:selected"?: ((val: {
+            value: boolean;
+        }) => any) | undefined;
+    }, {
+        groupItem: GroupItemProvide;
+    }, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+        'group:selected': (val: {
+            value: boolean;
+        }) => true;
+    }, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & {
+        style: vue.StyleValue;
+        eager: boolean;
+        disabled: boolean;
+    } & {
+        transition?: string | boolean | undefined;
+        value?: any;
+        class?: any;
+        selectedClass?: string | undefined;
+        reverseTransition?: string | boolean | undefined;
+    } & {
+        $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
+            default?: (() => vue.VNodeChild) | undefined;
+        };
+        'v-slots'?: {
+            default?: false | (() => vue.VNodeChild) | undefined;
+        } | undefined;
+    } & {
+        "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
+    } & {
+        "onGroup:selected"?: ((val: {
+            value: boolean;
+        }) => any) | undefined;
+    }, {
+        transition: string | boolean;
+        style: vue.StyleValue;
+        eager: boolean;
+        disabled: boolean;
+        reverseTransition: string | boolean;
+    }, true, {}, vue.SlotsType<Partial<{
+        default: () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+            [key: string]: any;
+        }>[];
+    }>>, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, {
+        style: vue.StyleValue;
+        eager: boolean;
+        disabled: boolean;
+    } & {
+        transition?: string | boolean | undefined;
+        value?: any;
+        class?: any;
+        selectedClass?: string | undefined;
+        reverseTransition?: string | boolean | undefined;
+    } & {
+        $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
+            default?: (() => vue.VNodeChild) | undefined;
+        };
+        'v-slots'?: {
+            default?: false | (() => vue.VNodeChild) | undefined;
+        } | undefined;
+    } & {
+        "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
+    } & {
+        "onGroup:selected"?: ((val: {
+            value: boolean;
+        }) => any) | undefined;
+    }, {
+        groupItem: GroupItemProvide;
+    }, {}, {}, {}, {
+        transition: string | boolean;
+        style: vue.StyleValue;
+        eager: boolean;
+        disabled: boolean;
+        reverseTransition: string | boolean;
+    }>;
+    __isFragment?: undefined;
+    __isTeleport?: undefined;
+    __isSuspense?: undefined;
+} & vue.ComponentOptionsBase<{
+    style: vue.StyleValue;
+    eager: boolean;
+    disabled: boolean;
+} & {
+    transition?: string | boolean | undefined;
+    value?: any;
+    class?: any;
+    selectedClass?: string | undefined;
+    reverseTransition?: string | boolean | undefined;
+} & {
+    $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
+        default?: (() => vue.VNodeChild) | undefined;
+    };
+    'v-slots'?: {
+        default?: false | (() => vue.VNodeChild) | undefined;
+    } | undefined;
+} & {
+    "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
+} & {
+    "onGroup:selected"?: ((val: {
+        value: boolean;
+    }) => any) | undefined;
+}, {
+    groupItem: GroupItemProvide;
+}, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+    'group:selected': (val: {
+        value: boolean;
+    }) => true;
+}, string, {
+    transition: string | boolean;
+    style: vue.StyleValue;
+    eager: boolean;
+    disabled: boolean;
+    reverseTransition: string | boolean;
+}, {}, string, vue.SlotsType<Partial<{
+    default: () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+        [key: string]: any;
+    }>[];
+}>>> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & FilterPropsOptions<{
+    eager: BooleanConstructor;
+    value: null;
+    disabled: BooleanConstructor;
+    selectedClass: StringConstructor;
+    class: vue.PropType<any>;
+    style: {
+        type: vue.PropType<vue.StyleValue>;
+        default: null;
+    };
+    reverseTransition: {
+        type: (StringConstructor | BooleanConstructor)[];
+        default: undefined;
+    };
+    transition: {
+        type: (StringConstructor | BooleanConstructor)[];
+        default: undefined;
+    };
+}, vue.ExtractPropTypes<{
+    eager: BooleanConstructor;
+    value: null;
+    disabled: BooleanConstructor;
+    selectedClass: StringConstructor;
+    class: vue.PropType<any>;
+    style: {
+        type: vue.PropType<vue.StyleValue>;
+        default: null;
+    };
+    reverseTransition: {
+        type: (StringConstructor | BooleanConstructor)[];
+        default: undefined;
+    };
+    transition: {
+        type: (StringConstructor | BooleanConstructor)[];
+        default: undefined;
+    };
+}>>;
+type VWindowItem = InstanceType<typeof VWindowItem>;
+
+export { VWindow, VWindowItem };

VApp/node_modules/vuetify/lib/components/VWindow/index.mjs

@@ -0,0 +1,3 @@
+export { VWindow } from "./VWindow.mjs";
+export { VWindowItem } from "./VWindowItem.mjs";
+//# sourceMappingURL=index.mjs.map

VApp/node_modules/vuetify/lib/components/VWindow/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":["VWindow","VWindowItem"],"sources":["../../../src/components/VWindow/index.ts"],"sourcesContent":["export { VWindow } from './VWindow'\nexport { VWindowItem } from './VWindowItem'\n"],"mappings":"SAASA,OAAO;AAAA,SACPC,WAAW"}