Tracking de l'application VApp (IHM du jeu)

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

@@ -0,0 +1,18 @@
+// Composables
+import { makeValidationProps, useValidation } from "../../composables/validation.mjs"; // Utilities
+import { genericComponent } from "../../util/index.mjs"; // Types
+export const VValidation = genericComponent()({
+  name: 'VValidation',
+  props: makeValidationProps(),
+  emits: {
+    'update:modelValue': value => true
+  },
+  setup(props, _ref) {
+    let {
+      slots
+    } = _ref;
+    const validation = useValidation(props, 'validation');
+    return () => slots.default?.(validation);
+  }
+});
+//# sourceMappingURL=VValidation.mjs.map

VApp/node_modules/vuetify/lib/components/VValidation/VValidation.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"VValidation.mjs","names":["makeValidationProps","useValidation","genericComponent","VValidation","name","props","emits","value","setup","_ref","slots","validation","default"],"sources":["../../../src/components/VValidation/VValidation.tsx"],"sourcesContent":["// Composables\nimport { makeValidationProps, useValidation } from '@/composables/validation'\n\n// Utilities\nimport { genericComponent } from '@/util'\n\n// Types\nimport type { GenericProps } from '@/util'\n\nexport type VValidationSlots = {\n  default: ReturnType<typeof useValidation>\n}\n\nexport const VValidation = genericComponent<new <T>(\n  props: {\n    modelValue?: T | null\n    'onUpdate:modelValue'?: (value: T | null) => void\n  },\n  slots: VValidationSlots,\n) => GenericProps<typeof props, typeof slots>>()({\n  name: 'VValidation',\n\n  props: makeValidationProps(),\n\n  emits: {\n    'update:modelValue': (value: any) => true,\n  },\n\n  setup (props, { slots }) {\n    const validation = useValidation(props, 'validation')\n\n    return () => slots.default?.(validation)\n  },\n})\n\nexport type VValidation = InstanceType<typeof VValidation>\n"],"mappings":"AAAA;AAAA,SACSA,mBAAmB,EAAEC,aAAa,4CAE3C;AAAA,SACSC,gBAAgB,gCAEzB;AAOA,OAAO,MAAMC,WAAW,GAAGD,gBAAgB,CAMI,CAAC,CAAC;EAC/CE,IAAI,EAAE,aAAa;EAEnBC,KAAK,EAAEL,mBAAmB,CAAC,CAAC;EAE5BM,KAAK,EAAE;IACL,mBAAmB,EAAGC,KAAU,IAAK;EACvC,CAAC;EAEDC,KAAKA,CAAEH,KAAK,EAAAI,IAAA,EAAa;IAAA,IAAX;MAAEC;IAAM,CAAC,GAAAD,IAAA;IACrB,MAAME,UAAU,GAAGV,aAAa,CAACI,KAAK,EAAE,YAAY,CAAC;IAErD,OAAO,MAAMK,KAAK,CAACE,OAAO,GAAGD,UAAU,CAAC;EAC1C;AACF,CAAC,CAAC"}

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

@@ -0,0 +1,279 @@
+import * as vue from 'vue';
+import { ComponentPropsOptions, ExtractPropTypes, VNodeChild, VNode, Ref, 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>>;
+}
+
+type MaybeRef<T> = T | Ref<T>;
+type EventProp<T extends any[] = any[], F = (...args: T) => void> = F;
+declare const EventProp: <T extends any[] = any[]>() => PropType<(...args: T) => void>;
+
+type ValidationResult = string | boolean;
+type ValidationRule = ValidationResult | PromiseLike<ValidationResult> | ((value: any) => ValidationResult) | ((value: any) => PromiseLike<ValidationResult>);
+type ValidateOnValue = 'blur' | 'input' | 'submit';
+interface ValidationProps {
+    disabled: boolean | null;
+    error: boolean;
+    errorMessages: string | readonly string[] | null;
+    focused: boolean;
+    maxErrors: string | number;
+    name: string | undefined;
+    label: string | undefined;
+    readonly: boolean | null;
+    rules: readonly ValidationRule[];
+    modelValue: any;
+    'onUpdate:modelValue': EventProp | undefined;
+    validateOn?: ValidateOnValue | `${ValidateOnValue} lazy` | `lazy ${ValidateOnValue}` | 'lazy';
+    validationValue: any;
+}
+declare function useValidation(props: ValidationProps, name?: string, id?: MaybeRef<string | number>): {
+    errorMessages: vue.ComputedRef<string[]>;
+    isDirty: vue.ComputedRef<boolean>;
+    isDisabled: vue.ComputedRef<boolean>;
+    isReadonly: vue.ComputedRef<boolean>;
+    isPristine: vue.ShallowRef<boolean>;
+    isValid: vue.ComputedRef<boolean | null>;
+    isValidating: vue.ShallowRef<boolean>;
+    reset: () => void;
+    resetValidation: () => void;
+    validate: (silent?: boolean) => Promise<string[]>;
+    validationClasses: vue.ComputedRef<{
+        [x: string]: boolean;
+    }>;
+};
+
+type VValidationSlots = {
+    default: ReturnType<typeof useValidation>;
+};
+declare const VValidation: {
+    new (...args: any[]): vue.CreateComponentPublicInstance<{
+        error: boolean;
+        disabled: boolean | null;
+        readonly: boolean | null;
+        focused: boolean;
+        errorMessages: string | readonly string[] | null;
+        maxErrors: string | number;
+        rules: readonly ValidationRule[];
+    } & {
+        name?: string | undefined;
+        label?: string | 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;
+    } & {}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+        [key: string]: any;
+    }>[] | 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 & {
+        error: boolean;
+        disabled: boolean | null;
+        readonly: boolean | null;
+        focused: boolean;
+        errorMessages: string | readonly string[] | null;
+        maxErrors: string | number;
+        rules: readonly ValidationRule[];
+    } & {
+        name?: string | undefined;
+        label?: string | 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;
+    } & {}, {
+        error: boolean;
+        disabled: boolean | null;
+        readonly: boolean | null;
+        focused: boolean;
+        errorMessages: string | readonly string[] | null;
+        maxErrors: string | number;
+        rules: readonly ValidationRule[];
+    }, true, {}, vue.SlotsType<Partial<{
+        default: (arg: {
+            errorMessages: vue.ComputedRef<string[]>;
+            isDirty: vue.ComputedRef<boolean>;
+            isDisabled: vue.ComputedRef<boolean>;
+            isReadonly: vue.ComputedRef<boolean>;
+            isPristine: vue.ShallowRef<boolean>;
+            isValid: vue.ComputedRef<boolean | null>;
+            isValidating: vue.ShallowRef<boolean>;
+            reset: () => void;
+            resetValidation: () => void;
+            validate: (silent?: boolean) => Promise<string[]>;
+            validationClasses: vue.ComputedRef<{
+                [x: string]: boolean;
+            }>;
+        }) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+            [key: string]: any;
+        }>[];
+    }>>, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, {
+        error: boolean;
+        disabled: boolean | null;
+        readonly: boolean | null;
+        focused: boolean;
+        errorMessages: string | readonly string[] | null;
+        maxErrors: string | number;
+        rules: readonly ValidationRule[];
+    } & {
+        name?: string | undefined;
+        label?: string | 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;
+    } & {}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+        [key: string]: any;
+    }>[] | undefined, {}, {}, {}, {
+        error: boolean;
+        disabled: boolean | null;
+        readonly: boolean | null;
+        focused: boolean;
+        errorMessages: string | readonly string[] | null;
+        maxErrors: string | number;
+        rules: readonly ValidationRule[];
+    }>;
+    __isFragment?: undefined;
+    __isTeleport?: undefined;
+    __isSuspense?: undefined;
+} & vue.ComponentOptionsBase<{
+    error: boolean;
+    disabled: boolean | null;
+    readonly: boolean | null;
+    focused: boolean;
+    errorMessages: string | readonly string[] | null;
+    maxErrors: string | number;
+    rules: readonly ValidationRule[];
+} & {
+    name?: string | undefined;
+    label?: string | 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;
+} & {}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>[] | undefined, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Omit<{
+    'update:modelValue': (value: any) => boolean;
+}, "$children" | "v-slot:default" | "v-slots" | "modelValue" | "update:modelValue">, string, {
+    error: boolean;
+    disabled: boolean | null;
+    readonly: boolean | null;
+    focused: boolean;
+    errorMessages: string | readonly string[] | null;
+    maxErrors: string | number;
+    rules: readonly ValidationRule[];
+}, {}, string, vue.SlotsType<Partial<{
+    default: (arg: {
+        errorMessages: vue.ComputedRef<string[]>;
+        isDirty: vue.ComputedRef<boolean>;
+        isDisabled: vue.ComputedRef<boolean>;
+        isReadonly: vue.ComputedRef<boolean>;
+        isPristine: vue.ShallowRef<boolean>;
+        isValid: vue.ComputedRef<boolean | null>;
+        isValidating: vue.ShallowRef<boolean>;
+        reset: () => void;
+        resetValidation: () => void;
+        validate: (silent?: boolean) => Promise<string[]>;
+        validationClasses: vue.ComputedRef<{
+            [x: string]: boolean;
+        }>;
+    }) => 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: VValidationSlots) => GenericProps<{
+    modelValue?: T | null | undefined;
+    'onUpdate:modelValue'?: ((value: T | null) => void) | undefined;
+}, VValidationSlots>) & FilterPropsOptions<{
+    focused: BooleanConstructor;
+    'onUpdate:focused': vue.PropType<(args_0: boolean) => void>;
+    disabled: {
+        type: vue.PropType<boolean | null>;
+        default: null;
+    };
+    error: BooleanConstructor;
+    errorMessages: {
+        type: vue.PropType<string | readonly string[] | null>;
+        default: () => never[];
+    };
+    maxErrors: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: number;
+    };
+    name: StringConstructor;
+    label: StringConstructor;
+    readonly: {
+        type: vue.PropType<boolean | null>;
+        default: null;
+    };
+    rules: {
+        type: vue.PropType<readonly ValidationRule[]>;
+        default: () => never[];
+    };
+    modelValue: null;
+    validateOn: vue.PropType<"lazy" | ("input" | "blur" | "submit") | "input lazy" | "blur lazy" | "submit lazy" | "lazy input" | "lazy blur" | "lazy submit" | undefined>;
+    validationValue: null;
+}, vue.ExtractPropTypes<{
+    focused: BooleanConstructor;
+    'onUpdate:focused': vue.PropType<(args_0: boolean) => void>;
+    disabled: {
+        type: vue.PropType<boolean | null>;
+        default: null;
+    };
+    error: BooleanConstructor;
+    errorMessages: {
+        type: vue.PropType<string | readonly string[] | null>;
+        default: () => never[];
+    };
+    maxErrors: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: number;
+    };
+    name: StringConstructor;
+    label: StringConstructor;
+    readonly: {
+        type: vue.PropType<boolean | null>;
+        default: null;
+    };
+    rules: {
+        type: vue.PropType<readonly ValidationRule[]>;
+        default: () => never[];
+    };
+    modelValue: null;
+    validateOn: vue.PropType<"lazy" | ("input" | "blur" | "submit") | "input lazy" | "blur lazy" | "submit lazy" | "lazy input" | "lazy blur" | "lazy submit" | undefined>;
+    validationValue: null;
+}>>;
+type VValidation = InstanceType<typeof VValidation>;
+
+export { VValidation };

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

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

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

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