Tracking de l'application VApp (IHM du jeu)

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

@@ -0,0 +1,115 @@
+.v-switch .v-label {
+  padding-inline-start: 10px;
+}
+.v-switch .v-switch__thumb {
+  background-color: rgb(var(--v-theme-surface-bright));
+  color: rgb(var(--v-theme-on-surface-bright));
+}
+
+.v-switch__loader {
+  display: flex;
+}
+.v-switch__loader .v-progress-circular {
+  color: rgb(var(--v-theme-surface));
+}
+
+.v-switch__track,
+.v-switch__thumb {
+  transition: none;
+}
+.v-selection-control--error:not(.v-selection-control--disabled) .v-switch__track,
+.v-selection-control--error:not(.v-selection-control--disabled) .v-switch__thumb {
+  background-color: rgb(var(--v-theme-error));
+  color: rgb(var(--v-theme-on-error));
+}
+
+.v-switch__track-true {
+  margin-inline-end: auto;
+}
+.v-selection-control:not(.v-selection-control--dirty) .v-switch__track-true {
+  opacity: 0;
+}
+
+.v-switch__track-false {
+  margin-inline-start: auto;
+}
+.v-selection-control--dirty .v-switch__track-false {
+  opacity: 0;
+}
+
+.v-switch__track {
+  display: inline-flex;
+  align-items: center;
+  font-size: 0.5rem;
+  padding: 0 5px;
+  background-color: rgb(var(--v-theme-surface-variant));
+  border-radius: 9999px;
+  height: 14px;
+  opacity: 0.6;
+  min-width: 36px;
+  cursor: pointer;
+  transition: 0.2s background-color cubic-bezier(0.4, 0, 0.2, 1);
+}
+.v-switch--inset .v-switch__track {
+  border-radius: 9999px;
+  font-size: 0.75rem;
+  height: 32px;
+  min-width: 52px;
+}
+
+.v-switch__thumb {
+  align-items: center;
+  border-radius: 50%;
+  display: flex;
+  font-size: 0.75rem;
+  height: 20px;
+  justify-content: center;
+  width: 20px;
+  pointer-events: none;
+  transition: 0.15s 0.05s transform cubic-bezier(0, 0, 0.2, 1), 0.2s color cubic-bezier(0.4, 0, 0.2, 1), 0.2s background-color cubic-bezier(0.4, 0, 0.2, 1);
+  position: relative;
+  overflow: hidden;
+  box-shadow: 0px 2px 4px -1px var(--v-shadow-key-umbra-opacity, rgba(0, 0, 0, 0.2)), 0px 4px 5px 0px var(--v-shadow-key-penumbra-opacity, rgba(0, 0, 0, 0.14)), 0px 1px 10px 0px var(--v-shadow-key-ambient-opacity, rgba(0, 0, 0, 0.12));
+}
+.v-switch--inset .v-switch__thumb {
+  height: 24px;
+  width: 24px;
+  transform: scale(0.6666666667);
+  box-shadow: 0px 0px 0px 0px var(--v-shadow-key-umbra-opacity, rgba(0, 0, 0, 0.2)), 0px 0px 0px 0px var(--v-shadow-key-penumbra-opacity, rgba(0, 0, 0, 0.14)), 0px 0px 0px 0px var(--v-shadow-key-ambient-opacity, rgba(0, 0, 0, 0.12));
+}
+.v-switch--inset .v-switch__thumb--filled {
+  transform: none;
+}
+.v-switch--inset .v-selection-control--dirty .v-switch__thumb {
+  transform: none;
+  transition: 0.15s 0.05s transform cubic-bezier(0, 0, 0.2, 1);
+}
+
+.v-switch.v-input {
+  flex: 0 1 auto;
+}
+.v-switch .v-selection-control {
+  min-height: var(--v-input-control-height);
+}
+.v-switch .v-selection-control__input {
+  border-radius: 50%;
+  transition: 0.2s transform cubic-bezier(0.4, 0, 0.2, 1);
+  transform: translateX(-10px);
+  position: absolute;
+}
+.v-switch .v-selection-control__input .v-icon {
+  position: absolute;
+}
+.v-switch .v-selection-control--dirty .v-selection-control__input {
+  transform: translateX(10px);
+}
+.v-switch.v-switch--indeterminate .v-selection-control__input {
+  transform: scale(0.8);
+}
+.v-switch.v-switch--indeterminate .v-switch__thumb {
+  transform: scale(0.75);
+  box-shadow: none;
+}
+.v-switch.v-switch--inset .v-selection-control__wrapper {
+  width: auto;
+}

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

@@ -0,0 +1,181 @@
+import { mergeProps as _mergeProps, Fragment as _Fragment, createVNode as _createVNode } from "vue";
+// Styles
+import "./VSwitch.css";
+
+// Components
+import { VScaleTransition } from "../transitions/index.mjs";
+import { VDefaultsProvider } from "../VDefaultsProvider/VDefaultsProvider.mjs";
+import { VIcon } from "../VIcon/index.mjs";
+import { makeVInputProps, VInput } from "../VInput/VInput.mjs";
+import { VProgressCircular } from "../VProgressCircular/index.mjs";
+import { makeVSelectionControlProps, VSelectionControl } from "../VSelectionControl/VSelectionControl.mjs"; // Composables
+import { useFocus } from "../../composables/focus.mjs";
+import { LoaderSlot, useLoader } from "../../composables/loader.mjs";
+import { useProxiedModel } from "../../composables/proxiedModel.mjs"; // Utilities
+import { computed, ref } from 'vue';
+import { filterInputAttrs, genericComponent, getUid, propsFactory, useRender } from "../../util/index.mjs"; // Types
+export const makeVSwitchProps = propsFactory({
+  indeterminate: Boolean,
+  inset: Boolean,
+  flat: Boolean,
+  loading: {
+    type: [Boolean, String],
+    default: false
+  },
+  ...makeVInputProps(),
+  ...makeVSelectionControlProps()
+}, 'VSwitch');
+export const VSwitch = genericComponent()({
+  name: 'VSwitch',
+  inheritAttrs: false,
+  props: makeVSwitchProps(),
+  emits: {
+    'update:focused': focused => true,
+    'update:modelValue': value => true,
+    'update:indeterminate': value => true
+  },
+  setup(props, _ref) {
+    let {
+      attrs,
+      slots
+    } = _ref;
+    const indeterminate = useProxiedModel(props, 'indeterminate');
+    const model = useProxiedModel(props, 'modelValue');
+    const {
+      loaderClasses
+    } = useLoader(props);
+    const {
+      isFocused,
+      focus,
+      blur
+    } = useFocus(props);
+    const control = ref();
+    const loaderColor = computed(() => {
+      return typeof props.loading === 'string' && props.loading !== '' ? props.loading : props.color;
+    });
+    const uid = getUid();
+    const id = computed(() => props.id || `switch-${uid}`);
+    function onChange() {
+      if (indeterminate.value) {
+        indeterminate.value = false;
+      }
+    }
+    function onTrackClick(e) {
+      e.stopPropagation();
+      e.preventDefault();
+      control.value?.input?.click();
+    }
+    useRender(() => {
+      const [rootAttrs, controlAttrs] = filterInputAttrs(attrs);
+      const inputProps = VInput.filterProps(props);
+      const controlProps = VSelectionControl.filterProps(props);
+      return _createVNode(VInput, _mergeProps({
+        "class": ['v-switch', {
+          'v-switch--inset': props.inset
+        }, {
+          'v-switch--indeterminate': indeterminate.value
+        }, loaderClasses.value, props.class]
+      }, rootAttrs, inputProps, {
+        "modelValue": model.value,
+        "onUpdate:modelValue": $event => model.value = $event,
+        "id": id.value,
+        "focused": isFocused.value,
+        "style": props.style
+      }), {
+        ...slots,
+        default: _ref2 => {
+          let {
+            id,
+            messagesId,
+            isDisabled,
+            isReadonly,
+            isValid
+          } = _ref2;
+          const slotProps = {
+            model,
+            isValid
+          };
+          return _createVNode(VSelectionControl, _mergeProps({
+            "ref": control
+          }, controlProps, {
+            "modelValue": model.value,
+            "onUpdate:modelValue": [$event => model.value = $event, onChange],
+            "id": id.value,
+            "aria-describedby": messagesId.value,
+            "type": "checkbox",
+            "aria-checked": indeterminate.value ? 'mixed' : undefined,
+            "disabled": isDisabled.value,
+            "readonly": isReadonly.value,
+            "onFocus": focus,
+            "onBlur": blur
+          }, controlAttrs), {
+            ...slots,
+            default: _ref3 => {
+              let {
+                backgroundColorClasses,
+                backgroundColorStyles
+              } = _ref3;
+              return _createVNode("div", {
+                "class": ['v-switch__track', ...backgroundColorClasses.value],
+                "style": backgroundColorStyles.value,
+                "onClick": onTrackClick
+              }, [slots['track-true'] && _createVNode("div", {
+                "key": "prepend",
+                "class": "v-switch__track-true"
+              }, [slots['track-true'](slotProps)]), slots['track-false'] && _createVNode("div", {
+                "key": "append",
+                "class": "v-switch__track-false"
+              }, [slots['track-false'](slotProps)])]);
+            },
+            input: _ref4 => {
+              let {
+                inputNode,
+                icon,
+                backgroundColorClasses,
+                backgroundColorStyles
+              } = _ref4;
+              return _createVNode(_Fragment, null, [inputNode, _createVNode("div", {
+                "class": ['v-switch__thumb', {
+                  'v-switch__thumb--filled': icon || props.loading
+                }, props.inset ? undefined : backgroundColorClasses.value],
+                "style": props.inset ? undefined : backgroundColorStyles.value
+              }, [slots.thumb ? _createVNode(VDefaultsProvider, {
+                "defaults": {
+                  VIcon: {
+                    icon,
+                    size: 'x-small'
+                  }
+                }
+              }, {
+                default: () => [slots.thumb({
+                  ...slotProps,
+                  icon
+                })]
+              }) : _createVNode(VScaleTransition, null, {
+                default: () => [!props.loading ? icon && _createVNode(VIcon, {
+                  "key": String(icon),
+                  "icon": icon,
+                  "size": "x-small"
+                }, null) : _createVNode(LoaderSlot, {
+                  "name": "v-switch",
+                  "active": true,
+                  "color": isValid.value === false ? undefined : loaderColor.value
+                }, {
+                  default: slotProps => slots.loader ? slots.loader(slotProps) : _createVNode(VProgressCircular, {
+                    "active": slotProps.isActive,
+                    "color": slotProps.color,
+                    "indeterminate": true,
+                    "size": "16",
+                    "width": "2"
+                  }, null)
+                })]
+              })])]);
+            }
+          });
+        }
+      });
+    });
+    return {};
+  }
+});
+//# sourceMappingURL=VSwitch.mjs.map

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

@@ -0,0 +1,119 @@
+@use 'sass:selector'
+@use '../../styles/settings'
+@use '../../styles/tools'
+@use './variables' as *
+
+.v-switch
+  .v-label
+    padding-inline-start: $switch-label-margin-inline-start
+
+  .v-switch__thumb
+    background-color: $switch-thumb-background
+    color: $switch-thumb-color
+
+.v-switch__loader
+  display: flex
+
+  .v-progress-circular
+    color: $switch-loader-color
+
+.v-switch__track,
+.v-switch__thumb
+  transition: none
+
+  .v-selection-control--error:not(.v-selection-control--disabled) &
+    background-color: $switch-error-background-color
+    color: $switch-error-color
+
+.v-switch__track-true
+  margin-inline-end: auto
+
+  .v-selection-control:not(.v-selection-control--dirty) &
+    opacity: 0
+
+.v-switch__track-false
+  margin-inline-start: auto
+
+  .v-selection-control--dirty &
+    opacity: 0
+
+.v-switch__track
+  display: inline-flex
+  align-items: center
+  font-size: .5rem
+  padding: 0 5px
+  background-color: $switch-track-background
+  border-radius: $switch-track-radius
+  height: $switch-track-height
+  opacity: $switch-track-opacity
+  min-width: $switch-track-width
+  cursor: pointer
+  transition: $switch-track-transition
+
+  .v-switch--inset &
+    border-radius: $switch-inset-track-border-radius
+    font-size: .75rem
+    height: $switch-inset-track-height
+    min-width: $switch-inset-track-width
+
+.v-switch__thumb
+  align-items: center
+  border-radius: $switch-thumb-radius
+  display: flex
+  font-size: .75rem
+  height: $switch-thumb-height
+  justify-content: center
+  width: $switch-thumb-width
+  pointer-events: none
+  transition: $switch-thumb-transition
+  position: relative
+  overflow: hidden
+
+  @include tools.elevation($switch-thumb-elevation)
+
+  .v-switch--inset &
+    height: $switch-inset-thumb-height
+    width: $switch-inset-thumb-width
+    transform: scale(calc($switch-inset-thumb-off-height / $switch-inset-thumb-height))
+
+    @include tools.elevation(0)
+
+    &--filled
+      transform: none
+
+  .v-switch--inset .v-selection-control--dirty &
+    transform: none
+    transition: .15s .05s transform settings.$decelerated-easing
+
+.v-switch
+  $switch-thumb-transform: $switch-track-width * .5 - $switch-thumb-width * .5 + $switch-thumb-offset
+
+  &.v-input
+    flex: $switch-flex
+
+  .v-selection-control
+    min-height: var(--v-input-control-height)
+
+  .v-selection-control__input
+    border-radius: 50%
+    transition: $switch-control-input-transition
+    transform: translateX(-$switch-thumb-transform)
+    position: absolute
+
+    .v-icon
+      position: absolute
+
+  .v-selection-control--dirty
+    .v-selection-control__input
+      transform: translateX($switch-thumb-transform)
+
+  &.v-switch--indeterminate
+    .v-selection-control__input
+      transform: scale(.8)
+    .v-switch__thumb
+      transform: scale(.75)
+      box-shadow: none
+
+  &.v-switch--inset
+    .v-selection-control__wrapper
+      width: auto

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

@@ -0,0 +1,34 @@
+@use '../../styles/settings';
+
+// VSwitch
+$switch-flex: 0 1 auto !default;
+$switch-control-input-transition: .2s transform settings.$standard-easing !default;
+$switch-error-background-color: rgb(var(--v-theme-error)) !default;
+$switch-error-color: rgb(var(--v-theme-on-error)) !default;
+
+$switch-inset-thumb-height: 24px !default;
+$switch-inset-thumb-width: 24px !default;
+$switch-inset-thumb-off-height: 16px !default;
+$switch-inset-thumb-off-width: 16px !default;
+$switch-inset-track-border-radius: 9999px !default;
+$switch-inset-track-height: 32px !default;
+$switch-inset-track-width: 52px !default;
+
+$switch-label-margin-inline-start: 10px !default;
+$switch-loader-color: rgb(var(--v-theme-surface)) !default;
+
+$switch-thumb-background: rgb(var(--v-theme-surface-bright)) !default;
+$switch-thumb-color: rgb(var(--v-theme-on-surface-bright)) !default;
+$switch-thumb-elevation: 4 !default;
+$switch-thumb-height: 20px !default;
+$switch-thumb-width: 20px !default;
+$switch-thumb-offset: 2px !default;
+$switch-thumb-radius: 50% !default;
+$switch-thumb-transition: .15s .05s transform settings.$decelerated-easing, .2s color settings.$standard-easing, .2s background-color settings.$standard-easing !default;
+
+$switch-track-background: rgb(var(--v-theme-surface-variant)) !default;
+$switch-track-radius: 9999px !default;
+$switch-track-width: 36px !default;
+$switch-track-height: 14px !default;
+$switch-track-opacity: .6 !default;
+$switch-track-transition: .2s background-color settings.$standard-easing !default;

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

@@ -0,0 +1,675 @@
+import * as vue from 'vue';
+import { ComponentPropsOptions, ExtractPropTypes, VNodeChild, VNode, JSXComponent, PropType, WritableComputedRef, Ref, CSSProperties, ComputedRef } 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>>;
+}
+
+declare function deepEqual(a: any, b: any): boolean;
+
+type Density = null | 'default' | 'comfortable' | 'compact';
+
+type IconValue = string | (string | [path: string, opacity: number])[] | JSXComponent;
+declare const IconValue: PropType<IconValue>;
+
+type SelectionControlSlot = {
+    model: WritableComputedRef<boolean>;
+    textColorClasses: Ref<string[]>;
+    textColorStyles: Ref<CSSProperties>;
+    backgroundColorClasses: Ref<string[]>;
+    backgroundColorStyles: Ref<CSSProperties>;
+    inputNode: VNode;
+    icon: IconValue | undefined;
+    props: {
+        onBlur: (e: Event) => void;
+        onFocus: (e: FocusEvent) => void;
+        id: string;
+    };
+};
+type VSelectionControlSlots = {
+    default: {
+        backgroundColorClasses: Ref<string[]>;
+        backgroundColorStyles: Ref<CSSProperties>;
+    };
+    label: {
+        label: string | undefined;
+        props: Record<string, unknown>;
+    };
+    input: SelectionControlSlot;
+};
+
+type VMessageSlot = {
+    message: string;
+};
+
+type ValidationResult = string | boolean;
+type ValidationRule = ValidationResult | PromiseLike<ValidationResult> | ((value: any) => ValidationResult) | ((value: any) => PromiseLike<ValidationResult>);
+
+interface VInputSlot {
+    id: ComputedRef<string>;
+    messagesId: ComputedRef<string>;
+    isDirty: ComputedRef<boolean>;
+    isDisabled: ComputedRef<boolean>;
+    isReadonly: ComputedRef<boolean>;
+    isPristine: Ref<boolean>;
+    isValid: ComputedRef<boolean | null>;
+    isValidating: Ref<boolean>;
+    reset: () => void;
+    resetValidation: () => void;
+    validate: () => void;
+}
+type VInputSlots = {
+    default: VInputSlot;
+    prepend: VInputSlot;
+    append: VInputSlot;
+    details: VInputSlot;
+    message: VMessageSlot;
+};
+
+interface LoaderSlotProps {
+    color: string | undefined;
+    isActive: boolean;
+}
+
+type VSwitchSlot = {
+    model: Ref<boolean>;
+    isValid: ComputedRef<boolean | null>;
+};
+type VSwitchSlots = VInputSlots & VSelectionControlSlots & {
+    loader: LoaderSlotProps;
+    thumb: {
+        icon: IconValue | undefined;
+    } & VSwitchSlot;
+    'track-false': VSwitchSlot;
+    'track-true': VSwitchSlot;
+};
+declare const VSwitch: {
+    new (...args: any[]): vue.CreateComponentPublicInstance<{
+        flat: boolean;
+        inline: boolean;
+        error: boolean;
+        direction: "horizontal" | "vertical";
+        inset: boolean;
+        loading: string | boolean;
+        style: vue.StyleValue;
+        disabled: boolean | null;
+        multiple: boolean | null;
+        readonly: boolean | null;
+        indeterminate: boolean;
+        messages: string | readonly string[];
+        density: Density;
+        ripple: boolean;
+        valueComparator: typeof deepEqual;
+        focused: boolean;
+        errorMessages: string | readonly string[] | null;
+        maxErrors: string | number;
+        rules: readonly ValidationRule[];
+        centerAffix: boolean;
+        hideSpinButtons: boolean;
+        persistentHint: boolean;
+    } & {
+        type?: string | undefined;
+        id?: string | undefined;
+        name?: string | undefined;
+        color?: string | undefined;
+        value?: any;
+        label?: string | undefined;
+        class?: any;
+        theme?: string | undefined;
+        prependIcon?: IconValue | undefined;
+        appendIcon?: IconValue | undefined;
+        defaultsTarget?: string | undefined;
+        falseIcon?: IconValue | undefined;
+        trueIcon?: IconValue | undefined;
+        baseColor?: string | undefined;
+        trueValue?: any;
+        falseValue?: any;
+        'onClick:append'?: ((args_0: MouseEvent) => void) | undefined;
+        'onClick:prepend'?: ((args_0: MouseEvent) => void) | undefined;
+        'onUpdate:focused'?: ((args_0: boolean) => void) | undefined;
+        validateOn?: "lazy" | ("input" | "blur" | "submit") | "input lazy" | "blur lazy" | "submit lazy" | "lazy input" | "lazy blur" | "lazy submit" | undefined;
+        validationValue?: any;
+        hint?: string | undefined;
+        hideDetails?: boolean | "auto" | undefined;
+    } & {
+        "onUpdate:indeterminate"?: ((value: boolean) => any) | undefined;
+        "onUpdate:focused"?: ((focused: boolean) => any) | undefined;
+    }, {}, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Omit<{
+        'update:focused': (focused: boolean) => boolean;
+        'update:modelValue': (value: any) => boolean;
+        'update:indeterminate': (value: boolean) => boolean;
+    }, "$children" | "v-slot:default" | "v-slots" | "v-slot:append" | "v-slot:prepend" | "modelValue" | "update:modelValue" | "v-slot:loader" | "v-slot:input" | "v-slot:label" | "v-slot:message" | "v-slot:details" | "v-slot:thumb" | "v-slot:track-false" | "v-slot:track-true">, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & {
+        flat: boolean;
+        inline: boolean;
+        error: boolean;
+        direction: "horizontal" | "vertical";
+        inset: boolean;
+        loading: string | boolean;
+        style: vue.StyleValue;
+        disabled: boolean | null;
+        multiple: boolean | null;
+        readonly: boolean | null;
+        indeterminate: boolean;
+        messages: string | readonly string[];
+        density: Density;
+        ripple: boolean;
+        valueComparator: typeof deepEqual;
+        focused: boolean;
+        errorMessages: string | readonly string[] | null;
+        maxErrors: string | number;
+        rules: readonly ValidationRule[];
+        centerAffix: boolean;
+        hideSpinButtons: boolean;
+        persistentHint: boolean;
+    } & {
+        type?: string | undefined;
+        id?: string | undefined;
+        name?: string | undefined;
+        color?: string | undefined;
+        value?: any;
+        label?: string | undefined;
+        class?: any;
+        theme?: string | undefined;
+        prependIcon?: IconValue | undefined;
+        appendIcon?: IconValue | undefined;
+        defaultsTarget?: string | undefined;
+        falseIcon?: IconValue | undefined;
+        trueIcon?: IconValue | undefined;
+        baseColor?: string | undefined;
+        trueValue?: any;
+        falseValue?: any;
+        'onClick:append'?: ((args_0: MouseEvent) => void) | undefined;
+        'onClick:prepend'?: ((args_0: MouseEvent) => void) | undefined;
+        'onUpdate:focused'?: ((args_0: boolean) => void) | undefined;
+        validateOn?: "lazy" | ("input" | "blur" | "submit") | "input lazy" | "blur lazy" | "submit lazy" | "lazy input" | "lazy blur" | "lazy submit" | undefined;
+        validationValue?: any;
+        hint?: string | undefined;
+        hideDetails?: boolean | "auto" | undefined;
+    } & {
+        "onUpdate:indeterminate"?: ((value: boolean) => any) | undefined;
+        "onUpdate:focused"?: ((focused: boolean) => any) | undefined;
+    }, {
+        flat: boolean;
+        inline: boolean;
+        error: boolean;
+        direction: "horizontal" | "vertical";
+        inset: boolean;
+        loading: string | boolean;
+        style: vue.StyleValue;
+        disabled: boolean | null;
+        multiple: boolean | null;
+        readonly: boolean | null;
+        indeterminate: boolean;
+        messages: string | readonly string[];
+        density: Density;
+        ripple: boolean;
+        valueComparator: typeof deepEqual;
+        focused: boolean;
+        errorMessages: string | readonly string[] | null;
+        maxErrors: string | number;
+        rules: readonly ValidationRule[];
+        centerAffix: boolean;
+        hideSpinButtons: boolean;
+        persistentHint: boolean;
+    }, true, {}, vue.SlotsType<Partial<{
+        default: (arg: VInputSlot & {
+            backgroundColorClasses: Ref<string[]>;
+            backgroundColorStyles: Ref<vue.CSSProperties>;
+        }) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+            [key: string]: any;
+        }>[];
+        prepend: (arg: VInputSlot) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+            [key: string]: any;
+        }>[];
+        append: (arg: VInputSlot) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+            [key: string]: any;
+        }>[];
+        details: (arg: VInputSlot) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+            [key: string]: any;
+        }>[];
+        message: (arg: VMessageSlot) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+            [key: string]: any;
+        }>[];
+        label: (arg: {
+            label: string | undefined;
+            props: Record<string, unknown>;
+        }) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+            [key: string]: any;
+        }>[];
+        input: (arg: SelectionControlSlot) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+            [key: string]: any;
+        }>[];
+        loader: (arg: LoaderSlotProps) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+            [key: string]: any;
+        }>[];
+        thumb: (arg: {
+            icon: IconValue | undefined;
+        } & VSwitchSlot) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+            [key: string]: any;
+        }>[];
+        'track-false': (arg: VSwitchSlot) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+            [key: string]: any;
+        }>[];
+        'track-true': (arg: VSwitchSlot) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+            [key: string]: any;
+        }>[];
+    }>>, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, {
+        flat: boolean;
+        inline: boolean;
+        error: boolean;
+        direction: "horizontal" | "vertical";
+        inset: boolean;
+        loading: string | boolean;
+        style: vue.StyleValue;
+        disabled: boolean | null;
+        multiple: boolean | null;
+        readonly: boolean | null;
+        indeterminate: boolean;
+        messages: string | readonly string[];
+        density: Density;
+        ripple: boolean;
+        valueComparator: typeof deepEqual;
+        focused: boolean;
+        errorMessages: string | readonly string[] | null;
+        maxErrors: string | number;
+        rules: readonly ValidationRule[];
+        centerAffix: boolean;
+        hideSpinButtons: boolean;
+        persistentHint: boolean;
+    } & {
+        type?: string | undefined;
+        id?: string | undefined;
+        name?: string | undefined;
+        color?: string | undefined;
+        value?: any;
+        label?: string | undefined;
+        class?: any;
+        theme?: string | undefined;
+        prependIcon?: IconValue | undefined;
+        appendIcon?: IconValue | undefined;
+        defaultsTarget?: string | undefined;
+        falseIcon?: IconValue | undefined;
+        trueIcon?: IconValue | undefined;
+        baseColor?: string | undefined;
+        trueValue?: any;
+        falseValue?: any;
+        'onClick:append'?: ((args_0: MouseEvent) => void) | undefined;
+        'onClick:prepend'?: ((args_0: MouseEvent) => void) | undefined;
+        'onUpdate:focused'?: ((args_0: boolean) => void) | undefined;
+        validateOn?: "lazy" | ("input" | "blur" | "submit") | "input lazy" | "blur lazy" | "submit lazy" | "lazy input" | "lazy blur" | "lazy submit" | undefined;
+        validationValue?: any;
+        hint?: string | undefined;
+        hideDetails?: boolean | "auto" | undefined;
+    } & {
+        "onUpdate:indeterminate"?: ((value: boolean) => any) | undefined;
+        "onUpdate:focused"?: ((focused: boolean) => any) | undefined;
+    }, {}, {}, {}, {}, {
+        flat: boolean;
+        inline: boolean;
+        error: boolean;
+        direction: "horizontal" | "vertical";
+        inset: boolean;
+        loading: string | boolean;
+        style: vue.StyleValue;
+        disabled: boolean | null;
+        multiple: boolean | null;
+        readonly: boolean | null;
+        indeterminate: boolean;
+        messages: string | readonly string[];
+        density: Density;
+        ripple: boolean;
+        valueComparator: typeof deepEqual;
+        focused: boolean;
+        errorMessages: string | readonly string[] | null;
+        maxErrors: string | number;
+        rules: readonly ValidationRule[];
+        centerAffix: boolean;
+        hideSpinButtons: boolean;
+        persistentHint: boolean;
+    }>;
+    __isFragment?: undefined;
+    __isTeleport?: undefined;
+    __isSuspense?: undefined;
+} & vue.ComponentOptionsBase<{
+    flat: boolean;
+    inline: boolean;
+    error: boolean;
+    direction: "horizontal" | "vertical";
+    inset: boolean;
+    loading: string | boolean;
+    style: vue.StyleValue;
+    disabled: boolean | null;
+    multiple: boolean | null;
+    readonly: boolean | null;
+    indeterminate: boolean;
+    messages: string | readonly string[];
+    density: Density;
+    ripple: boolean;
+    valueComparator: typeof deepEqual;
+    focused: boolean;
+    errorMessages: string | readonly string[] | null;
+    maxErrors: string | number;
+    rules: readonly ValidationRule[];
+    centerAffix: boolean;
+    hideSpinButtons: boolean;
+    persistentHint: boolean;
+} & {
+    type?: string | undefined;
+    id?: string | undefined;
+    name?: string | undefined;
+    color?: string | undefined;
+    value?: any;
+    label?: string | undefined;
+    class?: any;
+    theme?: string | undefined;
+    prependIcon?: IconValue | undefined;
+    appendIcon?: IconValue | undefined;
+    defaultsTarget?: string | undefined;
+    falseIcon?: IconValue | undefined;
+    trueIcon?: IconValue | undefined;
+    baseColor?: string | undefined;
+    trueValue?: any;
+    falseValue?: any;
+    'onClick:append'?: ((args_0: MouseEvent) => void) | undefined;
+    'onClick:prepend'?: ((args_0: MouseEvent) => void) | undefined;
+    'onUpdate:focused'?: ((args_0: boolean) => void) | undefined;
+    validateOn?: "lazy" | ("input" | "blur" | "submit") | "input lazy" | "blur lazy" | "submit lazy" | "lazy input" | "lazy blur" | "lazy submit" | undefined;
+    validationValue?: any;
+    hint?: string | undefined;
+    hideDetails?: boolean | "auto" | undefined;
+} & {
+    "onUpdate:indeterminate"?: ((value: boolean) => any) | undefined;
+    "onUpdate:focused"?: ((focused: boolean) => any) | undefined;
+}, {}, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Omit<{
+    'update:focused': (focused: boolean) => boolean;
+    'update:modelValue': (value: any) => boolean;
+    'update:indeterminate': (value: boolean) => boolean;
+}, "$children" | "v-slot:default" | "v-slots" | "v-slot:append" | "v-slot:prepend" | "modelValue" | "update:modelValue" | "v-slot:loader" | "v-slot:input" | "v-slot:label" | "v-slot:message" | "v-slot:details" | "v-slot:thumb" | "v-slot:track-false" | "v-slot:track-true">, string, {
+    flat: boolean;
+    inline: boolean;
+    error: boolean;
+    direction: "horizontal" | "vertical";
+    inset: boolean;
+    loading: string | boolean;
+    style: vue.StyleValue;
+    disabled: boolean | null;
+    multiple: boolean | null;
+    readonly: boolean | null;
+    indeterminate: boolean;
+    messages: string | readonly string[];
+    density: Density;
+    ripple: boolean;
+    valueComparator: typeof deepEqual;
+    focused: boolean;
+    errorMessages: string | readonly string[] | null;
+    maxErrors: string | number;
+    rules: readonly ValidationRule[];
+    centerAffix: boolean;
+    hideSpinButtons: boolean;
+    persistentHint: boolean;
+}, {}, string, vue.SlotsType<Partial<{
+    default: (arg: VInputSlot & {
+        backgroundColorClasses: Ref<string[]>;
+        backgroundColorStyles: Ref<vue.CSSProperties>;
+    }) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+        [key: string]: any;
+    }>[];
+    prepend: (arg: VInputSlot) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+        [key: string]: any;
+    }>[];
+    append: (arg: VInputSlot) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+        [key: string]: any;
+    }>[];
+    details: (arg: VInputSlot) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+        [key: string]: any;
+    }>[];
+    message: (arg: VMessageSlot) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+        [key: string]: any;
+    }>[];
+    label: (arg: {
+        label: string | undefined;
+        props: Record<string, unknown>;
+    }) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+        [key: string]: any;
+    }>[];
+    input: (arg: SelectionControlSlot) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+        [key: string]: any;
+    }>[];
+    loader: (arg: LoaderSlotProps) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+        [key: string]: any;
+    }>[];
+    thumb: (arg: {
+        icon: IconValue | undefined;
+    } & VSwitchSlot) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+        [key: string]: any;
+    }>[];
+    'track-false': (arg: VSwitchSlot) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+        [key: string]: any;
+    }>[];
+    'track-true': (arg: VSwitchSlot) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+        [key: string]: any;
+    }>[];
+}>>> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & (new <T>(props: {
+    modelValue?: T | null | undefined;
+    'onUpdate:modelValue'?: ((value: T | null) => void) | undefined;
+}, slots: VSwitchSlots) => GenericProps<{
+    modelValue?: T | null | undefined;
+    'onUpdate:modelValue'?: ((value: T | null) => void) | undefined;
+}, VSwitchSlots>) & FilterPropsOptions<{
+    theme: StringConstructor;
+    density: {
+        type: vue.PropType<Density>;
+        default: string;
+        validator: (v: any) => boolean;
+    };
+    class: vue.PropType<any>;
+    style: {
+        type: vue.PropType<vue.StyleValue>;
+        default: null;
+    };
+    color: StringConstructor;
+    disabled: {
+        type: vue.PropType<boolean | null>;
+        default: null;
+    };
+    defaultsTarget: StringConstructor;
+    error: BooleanConstructor;
+    id: StringConstructor;
+    inline: BooleanConstructor;
+    falseIcon: vue.PropType<IconValue>;
+    trueIcon: vue.PropType<IconValue>;
+    ripple: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    multiple: {
+        type: vue.PropType<boolean | null>;
+        default: null;
+    };
+    name: StringConstructor;
+    readonly: {
+        type: vue.PropType<boolean | null>;
+        default: null;
+    };
+    modelValue: null;
+    type: StringConstructor;
+    valueComparator: {
+        type: vue.PropType<typeof deepEqual>;
+        default: typeof deepEqual;
+    };
+    label: StringConstructor;
+    baseColor: StringConstructor;
+    trueValue: null;
+    falseValue: null;
+    value: null;
+    focused: BooleanConstructor;
+    'onUpdate:focused': vue.PropType<(args_0: boolean) => void>;
+    errorMessages: {
+        type: vue.PropType<string | readonly string[] | null>;
+        default: () => never[];
+    };
+    maxErrors: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: number;
+    };
+    rules: {
+        type: vue.PropType<readonly ValidationRule[]>;
+        default: () => never[];
+    };
+    validateOn: vue.PropType<"lazy" | ("input" | "blur" | "submit") | "input lazy" | "blur lazy" | "submit lazy" | "lazy input" | "lazy blur" | "lazy submit" | undefined>;
+    validationValue: null;
+    appendIcon: vue.PropType<IconValue>;
+    centerAffix: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    prependIcon: vue.PropType<IconValue>;
+    hideDetails: vue.PropType<boolean | "auto">;
+    hideSpinButtons: BooleanConstructor;
+    hint: StringConstructor;
+    persistentHint: BooleanConstructor;
+    messages: {
+        type: vue.PropType<string | readonly string[]>;
+        default: () => never[];
+    };
+    direction: {
+        type: vue.PropType<"horizontal" | "vertical">;
+        default: string;
+        validator: (v: any) => boolean;
+    };
+    'onClick:prepend': vue.PropType<(args_0: MouseEvent) => void>;
+    'onClick:append': vue.PropType<(args_0: MouseEvent) => void>;
+    indeterminate: BooleanConstructor;
+    inset: BooleanConstructor;
+    flat: BooleanConstructor;
+    loading: {
+        type: (StringConstructor | BooleanConstructor)[];
+        default: boolean;
+    };
+}, vue.ExtractPropTypes<{
+    theme: StringConstructor;
+    density: {
+        type: vue.PropType<Density>;
+        default: string;
+        validator: (v: any) => boolean;
+    };
+    class: vue.PropType<any>;
+    style: {
+        type: vue.PropType<vue.StyleValue>;
+        default: null;
+    };
+    color: StringConstructor;
+    disabled: {
+        type: vue.PropType<boolean | null>;
+        default: null;
+    };
+    defaultsTarget: StringConstructor;
+    error: BooleanConstructor;
+    id: StringConstructor;
+    inline: BooleanConstructor;
+    falseIcon: vue.PropType<IconValue>;
+    trueIcon: vue.PropType<IconValue>;
+    ripple: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    multiple: {
+        type: vue.PropType<boolean | null>;
+        default: null;
+    };
+    name: StringConstructor;
+    readonly: {
+        type: vue.PropType<boolean | null>;
+        default: null;
+    };
+    modelValue: null;
+    type: StringConstructor;
+    valueComparator: {
+        type: vue.PropType<typeof deepEqual>;
+        default: typeof deepEqual;
+    };
+    label: StringConstructor;
+    baseColor: StringConstructor;
+    trueValue: null;
+    falseValue: null;
+    value: null;
+    focused: BooleanConstructor;
+    'onUpdate:focused': vue.PropType<(args_0: boolean) => void>;
+    errorMessages: {
+        type: vue.PropType<string | readonly string[] | null>;
+        default: () => never[];
+    };
+    maxErrors: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: number;
+    };
+    rules: {
+        type: vue.PropType<readonly ValidationRule[]>;
+        default: () => never[];
+    };
+    validateOn: vue.PropType<"lazy" | ("input" | "blur" | "submit") | "input lazy" | "blur lazy" | "submit lazy" | "lazy input" | "lazy blur" | "lazy submit" | undefined>;
+    validationValue: null;
+    appendIcon: vue.PropType<IconValue>;
+    centerAffix: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    prependIcon: vue.PropType<IconValue>;
+    hideDetails: vue.PropType<boolean | "auto">;
+    hideSpinButtons: BooleanConstructor;
+    hint: StringConstructor;
+    persistentHint: BooleanConstructor;
+    messages: {
+        type: vue.PropType<string | readonly string[]>;
+        default: () => never[];
+    };
+    direction: {
+        type: vue.PropType<"horizontal" | "vertical">;
+        default: string;
+        validator: (v: any) => boolean;
+    };
+    'onClick:prepend': vue.PropType<(args_0: MouseEvent) => void>;
+    'onClick:append': vue.PropType<(args_0: MouseEvent) => void>;
+    indeterminate: BooleanConstructor;
+    inset: BooleanConstructor;
+    flat: BooleanConstructor;
+    loading: {
+        type: (StringConstructor | BooleanConstructor)[];
+        default: boolean;
+    };
+}>>;
+type VSwitch = InstanceType<typeof VSwitch>;
+
+export { VSwitch };

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

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

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

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