Tracking de l'application VApp (IHM du jeu)

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

@@ -0,0 +1,9 @@
+.v-selection-control-group {
+  grid-area: control;
+  display: flex;
+  flex-direction: column;
+}
+.v-selection-control-group--inline {
+  flex-direction: row;
+  flex-wrap: wrap;
+}

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

@@ -0,0 +1,110 @@
+import { createVNode as _createVNode } from "vue";
+// Styles
+import "./VSelectionControlGroup.css";
+
+// Composables
+import { makeComponentProps } from "../../composables/component.mjs";
+import { provideDefaults } from "../../composables/defaults.mjs";
+import { makeDensityProps } from "../../composables/density.mjs";
+import { IconValue } from "../../composables/icons.mjs";
+import { useProxiedModel } from "../../composables/proxiedModel.mjs";
+import { makeThemeProps } from "../../composables/theme.mjs"; // Utilities
+import { computed, onScopeDispose, provide, toRef } from 'vue';
+import { deepEqual, genericComponent, getUid, propsFactory, useRender } from "../../util/index.mjs"; // Types
+export const VSelectionControlGroupSymbol = Symbol.for('vuetify:selection-control-group');
+export const makeSelectionControlGroupProps = propsFactory({
+  color: String,
+  disabled: {
+    type: Boolean,
+    default: null
+  },
+  defaultsTarget: String,
+  error: Boolean,
+  id: String,
+  inline: Boolean,
+  falseIcon: IconValue,
+  trueIcon: IconValue,
+  ripple: {
+    type: Boolean,
+    default: true
+  },
+  multiple: {
+    type: Boolean,
+    default: null
+  },
+  name: String,
+  readonly: {
+    type: Boolean,
+    default: null
+  },
+  modelValue: null,
+  type: String,
+  valueComparator: {
+    type: Function,
+    default: deepEqual
+  },
+  ...makeComponentProps(),
+  ...makeDensityProps(),
+  ...makeThemeProps()
+}, 'SelectionControlGroup');
+export const makeVSelectionControlGroupProps = propsFactory({
+  ...makeSelectionControlGroupProps({
+    defaultsTarget: 'VSelectionControl'
+  })
+}, 'VSelectionControlGroup');
+export const VSelectionControlGroup = genericComponent()({
+  name: 'VSelectionControlGroup',
+  props: makeVSelectionControlGroupProps(),
+  emits: {
+    'update:modelValue': value => true
+  },
+  setup(props, _ref) {
+    let {
+      slots
+    } = _ref;
+    const modelValue = useProxiedModel(props, 'modelValue');
+    const uid = getUid();
+    const id = computed(() => props.id || `v-selection-control-group-${uid}`);
+    const name = computed(() => props.name || id.value);
+    const updateHandlers = new Set();
+    provide(VSelectionControlGroupSymbol, {
+      modelValue,
+      forceUpdate: () => {
+        updateHandlers.forEach(fn => fn());
+      },
+      onForceUpdate: cb => {
+        updateHandlers.add(cb);
+        onScopeDispose(() => {
+          updateHandlers.delete(cb);
+        });
+      }
+    });
+    provideDefaults({
+      [props.defaultsTarget]: {
+        color: toRef(props, 'color'),
+        disabled: toRef(props, 'disabled'),
+        density: toRef(props, 'density'),
+        error: toRef(props, 'error'),
+        inline: toRef(props, 'inline'),
+        modelValue,
+        multiple: computed(() => !!props.multiple || props.multiple == null && Array.isArray(modelValue.value)),
+        name,
+        falseIcon: toRef(props, 'falseIcon'),
+        trueIcon: toRef(props, 'trueIcon'),
+        readonly: toRef(props, 'readonly'),
+        ripple: toRef(props, 'ripple'),
+        type: toRef(props, 'type'),
+        valueComparator: toRef(props, 'valueComparator')
+      }
+    });
+    useRender(() => _createVNode("div", {
+      "class": ['v-selection-control-group', {
+        'v-selection-control-group--inline': props.inline
+      }, props.class],
+      "style": props.style,
+      "role": props.type === 'radio' ? 'radiogroup' : undefined
+    }, [slots.default?.()]));
+    return {};
+  }
+});
+//# sourceMappingURL=VSelectionControlGroup.mjs.map

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

@@ -0,0 +1,10 @@
+@use './variables' as *
+
+.v-selection-control-group
+  grid-area: $selection-control-group-grid-area
+  display: flex
+  flex-direction: column
+
+  &--inline
+    flex-direction: row
+    flex-wrap: wrap

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

@@ -0,0 +1 @@
+$selection-control-group-grid-area: control !default;

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

@@ -0,0 +1,280 @@
+import * as vue from 'vue';
+import { ComponentPropsOptions, ExtractPropTypes, VNodeChild, VNode, 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>>;
+}
+
+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>;
+
+declare const VSelectionControlGroup: {
+    new (...args: any[]): vue.CreateComponentPublicInstance<{
+        inline: boolean;
+        error: boolean;
+        style: vue.StyleValue;
+        disabled: boolean | null;
+        multiple: boolean | null;
+        readonly: boolean | null;
+        density: Density;
+        ripple: boolean;
+        defaultsTarget: string;
+        valueComparator: typeof deepEqual;
+    } & {
+        type?: string | undefined;
+        id?: string | undefined;
+        name?: string | undefined;
+        color?: string | undefined;
+        class?: any;
+        theme?: string | undefined;
+        falseIcon?: IconValue | undefined;
+        trueIcon?: IconValue | undefined;
+    } & {}, {}, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Omit<{
+        'update:modelValue': (value: any) => boolean;
+    }, "$children" | "v-slot:default" | "v-slots" | "modelValue" | "update:modelValue">, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & {
+        inline: boolean;
+        error: boolean;
+        style: vue.StyleValue;
+        disabled: boolean | null;
+        multiple: boolean | null;
+        readonly: boolean | null;
+        density: Density;
+        ripple: boolean;
+        defaultsTarget: string;
+        valueComparator: typeof deepEqual;
+    } & {
+        type?: string | undefined;
+        id?: string | undefined;
+        name?: string | undefined;
+        color?: string | undefined;
+        class?: any;
+        theme?: string | undefined;
+        falseIcon?: IconValue | undefined;
+        trueIcon?: IconValue | undefined;
+    } & {}, {
+        inline: boolean;
+        error: boolean;
+        style: vue.StyleValue;
+        disabled: boolean | null;
+        multiple: boolean | null;
+        readonly: boolean | null;
+        density: Density;
+        ripple: boolean;
+        defaultsTarget: string;
+        valueComparator: typeof deepEqual;
+    }, true, {}, vue.SlotsType<Partial<{
+        default: () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+            [key: string]: any;
+        }>[];
+    }>>, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, {
+        inline: boolean;
+        error: boolean;
+        style: vue.StyleValue;
+        disabled: boolean | null;
+        multiple: boolean | null;
+        readonly: boolean | null;
+        density: Density;
+        ripple: boolean;
+        defaultsTarget: string;
+        valueComparator: typeof deepEqual;
+    } & {
+        type?: string | undefined;
+        id?: string | undefined;
+        name?: string | undefined;
+        color?: string | undefined;
+        class?: any;
+        theme?: string | undefined;
+        falseIcon?: IconValue | undefined;
+        trueIcon?: IconValue | undefined;
+    } & {}, {}, {}, {}, {}, {
+        inline: boolean;
+        error: boolean;
+        style: vue.StyleValue;
+        disabled: boolean | null;
+        multiple: boolean | null;
+        readonly: boolean | null;
+        density: Density;
+        ripple: boolean;
+        defaultsTarget: string;
+        valueComparator: typeof deepEqual;
+    }>;
+    __isFragment?: undefined;
+    __isTeleport?: undefined;
+    __isSuspense?: undefined;
+} & vue.ComponentOptionsBase<{
+    inline: boolean;
+    error: boolean;
+    style: vue.StyleValue;
+    disabled: boolean | null;
+    multiple: boolean | null;
+    readonly: boolean | null;
+    density: Density;
+    ripple: boolean;
+    defaultsTarget: string;
+    valueComparator: typeof deepEqual;
+} & {
+    type?: string | undefined;
+    id?: string | undefined;
+    name?: string | undefined;
+    color?: string | undefined;
+    class?: any;
+    theme?: string | undefined;
+    falseIcon?: IconValue | undefined;
+    trueIcon?: IconValue | undefined;
+} & {}, {}, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Omit<{
+    'update:modelValue': (value: any) => boolean;
+}, "$children" | "v-slot:default" | "v-slots" | "modelValue" | "update:modelValue">, string, {
+    inline: boolean;
+    error: boolean;
+    style: vue.StyleValue;
+    disabled: boolean | null;
+    multiple: boolean | null;
+    readonly: boolean | null;
+    density: Density;
+    ripple: boolean;
+    defaultsTarget: string;
+    valueComparator: typeof deepEqual;
+}, {}, string, vue.SlotsType<Partial<{
+    default: () => 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: {
+    default: never;
+}) => GenericProps<{
+    modelValue?: T | undefined;
+    'onUpdate:modelValue'?: ((value: T) => void) | undefined;
+}, {
+    default: never;
+}>) & FilterPropsOptions<{
+    theme: StringConstructor;
+    density: {
+        type: PropType<Density>;
+        default: string;
+        validator: (v: any) => boolean;
+    };
+    class: PropType<any>;
+    style: {
+        type: PropType<vue.StyleValue>;
+        default: null;
+    };
+    color: StringConstructor;
+    disabled: {
+        type: PropType<boolean | null>;
+        default: null;
+    };
+    defaultsTarget: {
+        type: PropType<string>;
+        default: string;
+    };
+    error: BooleanConstructor;
+    id: StringConstructor;
+    inline: BooleanConstructor;
+    falseIcon: PropType<IconValue>;
+    trueIcon: PropType<IconValue>;
+    ripple: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    multiple: {
+        type: PropType<boolean | null>;
+        default: null;
+    };
+    name: StringConstructor;
+    readonly: {
+        type: PropType<boolean | null>;
+        default: null;
+    };
+    modelValue: null;
+    type: StringConstructor;
+    valueComparator: {
+        type: PropType<typeof deepEqual>;
+        default: typeof deepEqual;
+    };
+}, vue.ExtractPropTypes<{
+    theme: StringConstructor;
+    density: {
+        type: PropType<Density>;
+        default: string;
+        validator: (v: any) => boolean;
+    };
+    class: PropType<any>;
+    style: {
+        type: PropType<vue.StyleValue>;
+        default: null;
+    };
+    color: StringConstructor;
+    disabled: {
+        type: PropType<boolean | null>;
+        default: null;
+    };
+    defaultsTarget: {
+        type: PropType<string>;
+        default: string;
+    };
+    error: BooleanConstructor;
+    id: StringConstructor;
+    inline: BooleanConstructor;
+    falseIcon: PropType<IconValue>;
+    trueIcon: PropType<IconValue>;
+    ripple: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    multiple: {
+        type: PropType<boolean | null>;
+        default: null;
+    };
+    name: StringConstructor;
+    readonly: {
+        type: PropType<boolean | null>;
+        default: null;
+    };
+    modelValue: null;
+    type: StringConstructor;
+    valueComparator: {
+        type: PropType<typeof deepEqual>;
+        default: typeof deepEqual;
+    };
+}>>;
+type VSelectionControlGroup = InstanceType<typeof VSelectionControlGroup>;
+
+export { VSelectionControlGroup };

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

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

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

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