vue-lib-exo-corrected 1.0.1-beta.1 → 1.0.1-beta.2

package/dist/components/Organisms/Layout/Layout.vue.d.ts

@@ -1,2 +1,81 @@
-declare const _sfc_main: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+import type { PropType as __PropType } from 'vue';
+declare const _sfc_main: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    showTagsSidebar: {
+        type: __PropType<boolean>;
+        required: false;
+        default: boolean;
+    };
+    tags: {
+        type: __PropType<{
+            libelleName: string;
+            isSelected: boolean;
+            color?: string;
+        }[]>;
+        required: false;
+    };
+    sidebarTitle: {
+        type: __PropType<string>;
+        required: false;
+        default: string;
+    };
+    sidebarModelValue: {
+        type: __PropType<boolean>;
+        required: false;
+        default: boolean;
+    };
+    sidebarPermanent: {
+        type: __PropType<boolean>;
+        required: false;
+        default: boolean;
+    };
+    sidebarTemporary: {
+        type: __PropType<boolean>;
+        required: false;
+        default: boolean;
+    };
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("tag-click" | "tag-create" | "sidebar-update")[], "tag-click" | "tag-create" | "sidebar-update", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    showTagsSidebar: {
+        type: __PropType<boolean>;
+        required: false;
+        default: boolean;
+    };
+    tags: {
+        type: __PropType<{
+            libelleName: string;
+            isSelected: boolean;
+            color?: string;
+        }[]>;
+        required: false;
+    };
+    sidebarTitle: {
+        type: __PropType<string>;
+        required: false;
+        default: string;
+    };
+    sidebarModelValue: {
+        type: __PropType<boolean>;
+        required: false;
+        default: boolean;
+    };
+    sidebarPermanent: {
+        type: __PropType<boolean>;
+        required: false;
+        default: boolean;
+    };
+    sidebarTemporary: {
+        type: __PropType<boolean>;
+        required: false;
+        default: boolean;
+    };
+}>> & Readonly<{
+    "onTag-click"?: (...args: any[]) => any;
+    "onTag-create"?: (...args: any[]) => any;
+    "onSidebar-update"?: (...args: any[]) => any;
+}>, {
+    showTagsSidebar: boolean;
+    sidebarTitle: string;
+    sidebarModelValue: boolean;
+    sidebarPermanent: boolean;
+    sidebarTemporary: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
 export default _sfc_main;

package/dist/components/TodoListEasyExercice/AddItem.vue.d.ts

@@ -0,0 +1,4 @@
+declare const _sfc_main: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "add"[], "add", import("vue").PublicProps, Readonly<{}> & Readonly<{
+    onAdd?: (...args: any[]) => any;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _sfc_main;

package/dist/components/TodoListEasyExercice/TodoItem.vue.d.ts

@@ -0,0 +1,23 @@
+import type { PropType as __PropType } from 'vue';
+declare const _sfc_main: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    todo: {
+        type: __PropType<string>;
+        required: true;
+    };
+    index: {
+        type: __PropType<number>;
+        required: true;
+    };
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "delete"[], "delete", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    todo: {
+        type: __PropType<string>;
+        required: true;
+    };
+    index: {
+        type: __PropType<number>;
+        required: true;
+    };
+}>> & Readonly<{
+    onDelete?: (...args: any[]) => any;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _sfc_main;

package/dist/components/TodoListEasyExercice/TodoList.vue.d.ts

@@ -0,0 +1,16 @@
+import type { PropType as __PropType } from 'vue';
+declare const _sfc_main: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    todos: {
+        type: __PropType<string[]>;
+        required: true;
+    };
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("add" | "delete")[], "add" | "delete", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    todos: {
+        type: __PropType<string[]>;
+        required: true;
+    };
+}>> & Readonly<{
+    onAdd?: (...args: any[]) => any;
+    onDelete?: (...args: any[]) => any;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _sfc_main;

package/dist/components/TodoListEasyExercice/TodoListVModel.vue.d.ts

@@ -0,0 +1,15 @@
+import type { PropType as __PropType } from 'vue';
+declare const _sfc_main: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    modelValue: {
+        type: __PropType<string[]>;
+        required: true;
+    };
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "update:modelValue"[], "update:modelValue", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    modelValue: {
+        type: __PropType<string[]>;
+        required: true;
+    };
+}>> & Readonly<{
+    "onUpdate:modelValue"?: (...args: any[]) => any;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _sfc_main;

package/dist/composables/useValidation/useValidation.d.ts

@@ -0,0 +1,22 @@
+import { z, type ZodSchema } from 'zod';
+/**
+ * Composable de validation avec Zod
+ *
+ * @param schema - Schéma Zod pour valider les données
+ * @returns Objet avec errors, isTouched, validate, isValid
+ *
+ * @example
+ * ```typescript
+ * const { errors, validate, isValid } = useValidation(NoteCreateSchema)
+ *
+ * if (validate(formData.value)) {
+ *   // Données valides
+ * }
+ * ```
+ */
+export declare function useValidation<T extends ZodSchema>(schema: T): {
+    errors: import("vue").Ref<Record<string, string[]>, Record<string, string[]>>;
+    isTouched: import("vue").Ref<boolean, boolean>;
+    validate: (data: unknown) => data is z.TypeOf<T>;
+    isValid: import("vue").ComputedRef<boolean>;
+};

package/dist/index.d.ts

@@ -1,26 +1,32 @@
+import Dropdown from "./components/Atoms/Dropdown/Dropdown.vue";
+import Tag from "./components/Atoms/Tag/Tag.vue";
 import MarkdownText from "./components/Molecules/MarkdownText/MarkdownText.vue";
 import Layout from "./components/Organisms/Layout/Layout.vue";
 import ListLayout from "./components/Molecules/ListLayout/ListLayout.vue";
+import TodoList from "./components/TodoListEasyExercice/TodoList.vue";
+import TodoListVModel from "./components/TodoListEasyExercice/TodoListVModel.vue";
 import ListNote from "./components/Molecules/ListNote/ListNote.vue";
 import ListUsers from "./components/Molecules/ListUsers/ListUsers.vue";
 import NoteCard from "./components/Molecules/NoteCard/NoteCard.vue";
 import NoteCreation from "./components/Molecules/NoteCreation/NoteCreation.vue";
+import SidebarTags from "./components/Molecules/SidebarTags/SidebarTags.vue";
+import TagDropdown from "./components/Molecules/TagDropdown/TagDropdown.vue";
 import UserCard from "./components/Molecules/UserCard/UserCard.vue";
+import LoginForm from "./components/Molecules/LoginForm/LoginForm.vue";
+import RegisterForm from "./components/Molecules/RegisterForm/RegisterForm.vue";
 import { DEFAULT_VUETIFY_CONFIG } from "./lidinAppKitConfig/vuetifyConfig/defaultVuetifyConfig";
 import { createLidinAppKit } from "./lidinAppKitConfig/createLidinAppKit.ts";
 import { useLanguage } from "./modules/globalAppData/composables/useLanguage.ts";
 import { useTheme } from "./modules/globalAppData/composables/useTheme.ts";
+import { useValidation } from "./composables/useValidation/useValidation.ts";
 import { generateRandomUuid } from "./services/utils/randomId.ts";
 import { extractTitleFromMarkdown } from "./services/utils/markdownUtils.ts";
-export { useLanguage, useTheme, createLidinAppKit, DEFAULT_VUETIFY_CONFIG, MarkdownText, Layout, ListLayout, ListNote, ListUsers, NoteCard, NoteCreation, UserCard, generateRandomUuid, extractTitleFromMarkdown, };
+export type { NoteType, NoteCreateInput, NoteUpdateInput, } from "./types/NoteType";
+export type { TagType, TagCreateInput, TagUpdateInput, } from "./types/TagType";
+export { NoteCommonSchema, NoteCreateSchema, NoteUpdateSchema, type NoteCommon, type NoteCreate, type NoteUpdate, } from "./schemas/note.schema";
+export { TagCommonSchema, TagCreateSchema, TagUpdateSchema, type TagCommon, type TagCreate, type TagUpdate, } from "./schemas/tag.schema";
+export { useLanguage, useTheme, useValidation, createLidinAppKit, DEFAULT_VUETIFY_CONFIG, Dropdown, Tag, MarkdownText, Layout, ListLayout, ListNote, ListUsers, NoteCard, NoteCreation, SidebarTags, TagDropdown, UserCard, LoginForm, RegisterForm, TodoList, TodoListVModel, generateRandomUuid, extractTitleFromMarkdown, };
 
 import type { DefineComponent } from 'vue';
 
-export declare const MarkdownText: DefineComponent<{}, {}, any>;
-export declare const Layout: DefineComponent<{}, {}, any>;
-export declare const ListLayout: DefineComponent<{}, {}, any>;
-export declare const ListNote: DefineComponent<{}, {}, any>;
-export declare const ListUsers: DefineComponent<{}, {}, any>;
-export declare const NoteCard: DefineComponent<{}, {}, any>;
-export declare const NoteCreation: DefineComponent<{}, {}, any>;
-export declare const UserCard: DefineComponent<{}, {}, any>;
+

package/dist/lidinAppKitConfig/createLidinAppKit.d.ts

@@ -2,7 +2,13 @@ import { type VuetifyOptions } from "vuetify";
 export declare function createLidinAppKit(vuetify: VuetifyOptions): {
     install: (app: import("vue").App<any>) => void;
     unmount: () => void;
-    defaults: import("vue").Ref<import("vuetify").DefaultsInstance, import("vuetify").DefaultsInstance>;
+    defaults: import("vue").Ref<{
+        [key: string]: Record<string, unknown>;
+        global?: Record<string, unknown>;
+    }, {
+        [key: string]: Record<string, unknown>;
+        global?: Record<string, unknown>;
+    }>;
     display: import("vuetify").DisplayInstance;
     theme: import("vuetify").ThemeInstance & {
         install: (app: import("vue").App<any>) => void;
@@ -31,7 +37,7 @@ export declare function createLidinAppKit(vuetify: VuetifyOptions): {
                 locale: any;
                 formats?: any;
             }) => import("vuetify").DateInstance) | import("vuetify").DateInstance;
-            formats?: Record<string, any> | undefined;
+            formats?: Record<string, any>;
             locale: Record<string, any>;
         };
         instance: {
@@ -42,7 +48,7 @@ export declare function createLidinAppKit(vuetify: VuetifyOptions): {
             toISO: (date: unknown) => string;
             startOfDay: (date: unknown) => unknown;
             endOfDay: (date: unknown) => unknown;
-            startOfWeek: (date: unknown, firstDayOfWeek?: string | number | undefined) => unknown;
+            startOfWeek: (date: unknown, firstDayOfWeek?: string | number) => unknown;
             endOfWeek: (date: unknown) => unknown;
             startOfMonth: (date: unknown) => unknown;
             endOfMonth: (date: unknown) => unknown;
@@ -64,10 +70,10 @@ export declare function createLidinAppKit(vuetify: VuetifyOptions): {
             addMonths: (date: unknown, amount: number) => unknown;
             getYear: (date: unknown) => number;
             setYear: (date: unknown, year: number) => unknown;
-            getDiff: (date: unknown, comparing: unknown, unit?: string | undefined) => number;
-            getWeekArray: (date: unknown, firstDayOfWeek?: string | number | undefined) => unknown[][];
-            getWeekdays: (firstDayOfWeek?: string | number | undefined, weekdayFormat?: "long" | "narrow" | "short" | undefined) => string[];
-            getWeek: (date: unknown, firstDayOfWeek?: string | number | undefined, firstDayOfYear?: string | number | undefined) => number;
+            getDiff: (date: unknown, comparing: unknown, unit?: string) => number;
+            getWeekArray: (date: unknown, firstDayOfWeek?: string | number) => unknown[][];
+            getWeekdays: (firstDayOfWeek?: string | number, weekdayFormat?: "long" | "narrow" | "short") => string[];
+            getWeek: (date: unknown, firstDayOfWeek?: string | number, firstDayOfYear?: string | number) => number;
             getMonth: (date: unknown) => number;
             setMonth: (date: unknown, month: number) => unknown;
             getDate: (date: unknown) => number;

package/dist/lidinAppKitConfig/vuetifyConfig/defaultVuetifyConfig.d.ts

@@ -6,54 +6,54 @@ export declare const DEFAULT_VUETIFY_CONFIG: {
         defaultTheme: string;
         themes: {
             light: {
-                dark?: boolean | undefined;
+                dark?: boolean;
                 colors?: {
-                    [x: string]: string | undefined;
-                    background?: string | undefined;
-                    surface?: string | undefined;
-                    primary?: string | undefined;
-                    secondary?: string | undefined;
-                    success?: string | undefined;
-                    warning?: string | undefined;
-                    error?: string | undefined;
-                    info?: string | undefined;
-                    'on-background'?: string | undefined;
-                    'on-surface'?: string | undefined;
-                    'on-primary'?: string | undefined;
-                    'on-secondary'?: string | undefined;
-                    'on-success'?: string | undefined;
-                    'on-warning'?: string | undefined;
-                    'on-error'?: string | undefined;
-                    'on-info'?: string | undefined;
-                } | undefined;
+                    [x: string]: string;
+                    background?: string;
+                    surface?: string;
+                    primary?: string;
+                    secondary?: string;
+                    success?: string;
+                    warning?: string;
+                    error?: string;
+                    info?: string;
+                    'on-background'?: string;
+                    'on-surface'?: string;
+                    'on-primary'?: string;
+                    'on-secondary'?: string;
+                    'on-success'?: string;
+                    'on-warning'?: string;
+                    'on-error'?: string;
+                    'on-info'?: string;
+                };
                 variables?: {
-                    [x: string]: string | number | undefined;
-                } | undefined;
+                    [x: string]: string | number;
+                };
             };
             dark: {
-                dark?: boolean | undefined;
+                dark?: boolean;
                 colors?: {
-                    [x: string]: string | undefined;
-                    background?: string | undefined;
-                    surface?: string | undefined;
-                    primary?: string | undefined;
-                    secondary?: string | undefined;
-                    success?: string | undefined;
-                    warning?: string | undefined;
-                    error?: string | undefined;
-                    info?: string | undefined;
-                    'on-background'?: string | undefined;
-                    'on-surface'?: string | undefined;
-                    'on-primary'?: string | undefined;
-                    'on-secondary'?: string | undefined;
-                    'on-success'?: string | undefined;
-                    'on-warning'?: string | undefined;
-                    'on-error'?: string | undefined;
-                    'on-info'?: string | undefined;
-                } | undefined;
+                    [x: string]: string;
+                    background?: string;
+                    surface?: string;
+                    primary?: string;
+                    secondary?: string;
+                    success?: string;
+                    warning?: string;
+                    error?: string;
+                    info?: string;
+                    'on-background'?: string;
+                    'on-surface'?: string;
+                    'on-primary'?: string;
+                    'on-secondary'?: string;
+                    'on-success'?: string;
+                    'on-warning'?: string;
+                    'on-error'?: string;
+                    'on-info'?: string;
+                };
                 variables?: {
-                    [x: string]: string | number | undefined;
-                } | undefined;
+                    [x: string]: string | number;
+                };
             };
         };
     };

package/dist/schemas/note.schema.d.ts

@@ -0,0 +1,77 @@
+import { z } from 'zod';
+/**
+ * Schéma commun pour Note (base réutilisable)
+ */
+export declare const NoteCommonSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    contentMd: z.ZodString;
+    tagsId: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    createdAt: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    contentMd?: string;
+    id?: string;
+    tagsId?: string[];
+    createdAt?: string;
+}, {
+    contentMd?: string;
+    id?: string;
+    tagsId?: string[];
+    createdAt?: string;
+}>;
+/**
+ * Schéma pour la création d'une note
+ * - Pas d'id (généré côté serveur)
+ * - Pas de createdAt (généré côté serveur)
+ * - title optionnel (peut être extrait du contentMd)
+ * - contentMd optionnel si title est présent (au moins un des deux requis)
+ */
+export declare const NoteCreateSchema: z.ZodEffects<z.ZodObject<{
+    tagsId: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+} & {
+    title: z.ZodOptional<z.ZodString>;
+    contentMd: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    title?: string;
+    contentMd?: string;
+    tagsId?: string[];
+}, {
+    title?: string;
+    contentMd?: string;
+    tagsId?: string[];
+}>, {
+    title?: string;
+    contentMd?: string;
+    tagsId?: string[];
+}, {
+    title?: string;
+    contentMd?: string;
+    tagsId?: string[];
+}>;
+/**
+ * Schéma pour la mise à jour d'une note
+ * - id requis
+ * - Tous les autres champs optionnels (partial update)
+ */
+export declare const NoteUpdateSchema: z.ZodObject<{
+    contentMd: z.ZodOptional<z.ZodString>;
+    tagsId: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
+    createdAt: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+} & {
+    id: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    contentMd?: string;
+    id?: string;
+    tagsId?: string[];
+    createdAt?: string;
+}, {
+    contentMd?: string;
+    id?: string;
+    tagsId?: string[];
+    createdAt?: string;
+}>;
+/**
+ * Inférence de types depuis les schémas
+ */
+export type NoteCommon = z.infer<typeof NoteCommonSchema>;
+export type NoteCreate = z.infer<typeof NoteCreateSchema>;
+export type NoteUpdate = z.infer<typeof NoteUpdateSchema>;

package/dist/schemas/note.schema.ts

@@ -0,0 +1,47 @@
+import { z } from 'zod';
+
+/**
+ * Schéma commun pour Note (base réutilisable)
+ */
+export const NoteCommonSchema = z.object({
+  id: z.string().optional(),
+  contentMd: z.string().min(1, 'Contenu requis'),
+  tagsId: z.array(z.string()).optional(),
+  createdAt: z.string().datetime().optional(),
+});
+
+/**
+ * Schéma pour la création d'une note
+ * - Pas d'id (généré côté serveur)
+ * - Pas de createdAt (généré côté serveur)
+ * - title optionnel (peut être extrait du contentMd)
+ * - contentMd optionnel si title est présent (au moins un des deux requis)
+ */
+export const NoteCreateSchema = NoteCommonSchema.omit({ id: true, createdAt: true })
+  .extend({
+    title: z.string().optional(),
+    contentMd: z.string().optional(),
+  })
+  .refine(
+    (data) => data.title || data.contentMd,
+    {
+      message: 'Au moins un titre ou un contenu est requis',
+      path: ['contentMd'],
+    }
+  );
+
+/**
+ * Schéma pour la mise à jour d'une note
+ * - id requis
+ * - Tous les autres champs optionnels (partial update)
+ */
+export const NoteUpdateSchema = NoteCommonSchema.partial().extend({
+  id: z.string(),
+});
+
+/**
+ * Inférence de types depuis les schémas
+ */
+export type NoteCommon = z.infer<typeof NoteCommonSchema>;
+export type NoteCreate = z.infer<typeof NoteCreateSchema>;
+export type NoteUpdate = z.infer<typeof NoteUpdateSchema>;

package/dist/schemas/tag.schema.d.ts

@@ -0,0 +1,57 @@
+import { z } from 'zod';
+/**
+ * Schéma commun pour Tag (base réutilisable)
+ */
+export declare const TagCommonSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    title: z.ZodString;
+    color: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    title?: string;
+    color?: string;
+    id?: string;
+}, {
+    title?: string;
+    color?: string;
+    id?: string;
+}>;
+/**
+ * Schéma pour la création d'un tag
+ * - Pas d'id (généré côté serveur)
+ */
+export declare const TagCreateSchema: z.ZodObject<Omit<{
+    id: z.ZodOptional<z.ZodString>;
+    title: z.ZodString;
+    color: z.ZodString;
+}, "id">, "strip", z.ZodTypeAny, {
+    title?: string;
+    color?: string;
+}, {
+    title?: string;
+    color?: string;
+}>;
+/**
+ * Schéma pour la mise à jour d'un tag
+ * - id requis
+ * - Tous les autres champs optionnels (partial update)
+ */
+export declare const TagUpdateSchema: z.ZodObject<{
+    title: z.ZodOptional<z.ZodString>;
+    color: z.ZodOptional<z.ZodString>;
+} & {
+    id: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    title?: string;
+    color?: string;
+    id?: string;
+}, {
+    title?: string;
+    color?: string;
+    id?: string;
+}>;
+/**
+ * Inférence de types depuis les schémas
+ */
+export type TagCommon = z.infer<typeof TagCommonSchema>;
+export type TagCreate = z.infer<typeof TagCreateSchema>;
+export type TagUpdate = z.infer<typeof TagUpdateSchema>;

package/dist/schemas/tag.schema.ts

@@ -0,0 +1,32 @@
+import { z } from 'zod';
+
+/**
+ * Schéma commun pour Tag (base réutilisable)
+ */
+export const TagCommonSchema = z.object({
+  id: z.string().optional(),
+  title: z.string().min(1, 'Titre requis'),
+  color: z.string().regex(/^#[0-9A-Fa-f]{6}$/, 'Couleur doit être au format hex (#RRGGBB)'),
+});
+
+/**
+ * Schéma pour la création d'un tag
+ * - Pas d'id (généré côté serveur)
+ */
+export const TagCreateSchema = TagCommonSchema.omit({ id: true });
+
+/**
+ * Schéma pour la mise à jour d'un tag
+ * - id requis
+ * - Tous les autres champs optionnels (partial update)
+ */
+export const TagUpdateSchema = TagCommonSchema.partial().extend({
+  id: z.string(),
+});
+
+/**
+ * Inférence de types depuis les schémas
+ */
+export type TagCommon = z.infer<typeof TagCommonSchema>;
+export type TagCreate = z.infer<typeof TagCreateSchema>;
+export type TagUpdate = z.infer<typeof TagUpdateSchema>;