@wasto/cms-components 1.5.10 → 1.5.11

package/src/hooks/useBlogPosts.ts

@@ -1,105 +1,109 @@
-import { useCallback, useEffect, useState } from "react";
-import { useNextCollection } from "./useNextCollection";
-import { useWastoClient } from "./useWastoClient";
-import { normalizeBlogPost, type BlogPost } from "../helpers/blogPost";
-
-function cityGroupIdFromCity(city: Record<string, unknown> | null): string | undefined {
-    if (!city) return undefined;
-    const raw =
-        city.cityGroupId ??
-        city.city_group_id ??
-        (city.cityGroup != null && typeof city.cityGroup === "object"
-            ? (city.cityGroup as { id?: unknown }).id
-            : undefined);
-    return typeof raw === "string" && raw.trim() ? raw.trim() : undefined;
-}
-
-export type UseBlogPostsResult = {
-    posts: BlogPost[];
-    isLoading: boolean;
-    error: string | null;
-    refetch: () => Promise<void>;
-};
-
-export function useBlogPosts(options: { pageSize?: number } = {}): UseBlogPostsResult {
-    const { city } = useNextCollection();
-    const client = useWastoClient();
-    const pageSize = options.pageSize ?? 50;
-    const cityGroupId = cityGroupIdFromCity(city as Record<string, unknown> | null);
-
-    const [posts, setPosts] = useState<BlogPost[]>([]);
-    const [isLoading, setIsLoading] = useState(false);
-    const [error, setError] = useState<string | null>(null);
-
-    const fetchPosts = useCallback(async () => {
-        try {
-            setIsLoading(true);
-            setError(null);
-            const res = await client.public.blogPosts.list(cityGroupId, { pageSize });
-            const data = (res as { data?: unknown })?.data;
-            const list = Array.isArray(data) ? data : [];
-            setPosts(list.map(normalizeBlogPost).filter((p): p is BlogPost => p != null));
-        } catch (err) {
-            setError(
-                err instanceof Error ? err.message : "Impossible de charger les articles"
-            );
-            setPosts([]);
-        } finally {
-            setIsLoading(false);
-        }
-    }, [cityGroupId, client.public.blogPosts, pageSize]);
-
-    useEffect(() => {
-        void fetchPosts();
-    }, [fetchPosts]);
-
-    return { posts, isLoading, error, refetch: fetchPosts };
-}
-
-export type UseBlogPostResult = {
-    post: BlogPost | null;
-    isLoading: boolean;
-    error: string | null;
-};
-
-export function useBlogPost(articleId: string): UseBlogPostResult {
-    const client = useWastoClient();
-    const [post, setPost] = useState<BlogPost | null>(null);
-    const [isLoading, setIsLoading] = useState(false);
-    const [error, setError] = useState<string | null>(null);
-
-    useEffect(() => {
-        const id = articleId.trim();
-        if (!id) {
-            setPost(null);
-            setError(null);
-            setIsLoading(false);
-            return;
-        }
-
-        let cancelled = false;
-        const run = async () => {
-            try {
-                setIsLoading(true);
-                setError(null);
-                const res = await client.public.blogPosts.getById(id);
-                if (cancelled) return;
-                const normalized = normalizeBlogPost(res);
-                setPost(normalized);
-                if (!normalized) setError("Article introuvable");
-            } catch (err) {
-                if (cancelled) return;
-                setPost(null);
-                setError(err instanceof Error ? err.message : "Impossible de charger l'article");
-            } finally {
-                if (!cancelled) setIsLoading(false);
-            }
-        };
-        void run();
-        return () => {
-            cancelled = true;
-        };
-    }, [articleId, client.public.blogPosts]);
-
-    return { post, isLoading, error };
-}
+import { useCallback, useEffect, useState } from "react";
+import { useWasto } from "../contexts/WastoContext";
+import { normalizeBlogPost, type BlogPost } from "../helpers/blogPost";
+import { useNextCollection } from "./useNextCollection";
+import { useWastoClient } from "./useWastoClient";
+
+function cityGroupIdFromCity(city: Record<string, unknown> | null): string | undefined {
+    if (!city) return undefined;
+    const raw =
+        city.cityGroupId ??
+        city.city_group_id ??
+        (city.cityGroup != null && typeof city.cityGroup === "object"
+            ? (city.cityGroup as { id?: unknown }).id
+            : undefined);
+    return typeof raw === "string" && raw.trim() ? raw.trim() : undefined;
+}
+
+export type UseBlogPostsResult = {
+    posts: BlogPost[];
+    isLoading: boolean;
+    error: string | null;
+    refetch: () => Promise<void>;
+};
+
+export function useBlogPosts(options: { pageSize?: number } = {}): UseBlogPostsResult {
+    const { city } = useNextCollection();
+    const { cityGroupId: contextCityGroupId } = useWasto();
+    const client = useWastoClient();
+    const pageSize = options.pageSize ?? 50;
+    const cityGroupId =
+        cityGroupIdFromCity(city as Record<string, unknown> | null) ??
+        (contextCityGroupId?.trim() || undefined);
+
+    const [posts, setPosts] = useState<BlogPost[]>([]);
+    const [isLoading, setIsLoading] = useState(false);
+    const [error, setError] = useState<string | null>(null);
+
+    const fetchPosts = useCallback(async () => {
+        try {
+            setIsLoading(true);
+            setError(null);
+            const res = await client.public.blogPosts.list(cityGroupId, { pageSize });
+            const data = (res as { data?: unknown })?.data;
+            const list = Array.isArray(data) ? data : [];
+            setPosts(list.map(normalizeBlogPost).filter((p): p is BlogPost => p != null));
+        } catch (err) {
+            setError(
+                err instanceof Error ? err.message : "Impossible de charger les articles"
+            );
+            setPosts([]);
+        } finally {
+            setIsLoading(false);
+        }
+    }, [cityGroupId, client.public.blogPosts, pageSize]);
+
+    useEffect(() => {
+        void fetchPosts();
+    }, [fetchPosts]);
+
+    return { posts, isLoading, error, refetch: fetchPosts };
+}
+
+export type UseBlogPostResult = {
+    post: BlogPost | null;
+    isLoading: boolean;
+    error: string | null;
+};
+
+export function useBlogPost(articleId: string): UseBlogPostResult {
+    const client = useWastoClient();
+    const [post, setPost] = useState<BlogPost | null>(null);
+    const [isLoading, setIsLoading] = useState(false);
+    const [error, setError] = useState<string | null>(null);
+
+    useEffect(() => {
+        const id = articleId.trim();
+        if (!id) {
+            setPost(null);
+            setError(null);
+            setIsLoading(false);
+            return;
+        }
+
+        let cancelled = false;
+        const run = async () => {
+            try {
+                setIsLoading(true);
+                setError(null);
+                const res = await client.public.blogPosts.getById(id);
+                if (cancelled) return;
+                const normalized = normalizeBlogPost(res);
+                setPost(normalized);
+                if (!normalized) setError("Article introuvable");
+            } catch (err) {
+                if (cancelled) return;
+                setPost(null);
+                setError(err instanceof Error ? err.message : "Impossible de charger l'article");
+            } finally {
+                if (!cancelled) setIsLoading(false);
+            }
+        };
+        void run();
+        return () => {
+            cancelled = true;
+        };
+    }, [articleId, client.public.blogPosts]);
+
+    return { post, isLoading, error };
+}

package/src/hooks/useChallenges.ts

@@ -1,110 +1,110 @@
-import { useChallengesContext } from "../contexts/ChallengesContext";
-
-export type Challenge = {
-    id: string;
-    name: string;
-    description?: string;
-    imageUrl?: string | null;
-    enabled?: boolean;
-    startDate?: string;
-    endDate?: string;
-    order?: number;
-    requiredChallengeId?: string | null;
-    requiredChallenge?: { id: string; name: string } | null;
-    series?: Array<{
-        id: string;
-        challengeId: string;
-        name: string;
-        description?: string;
-        imageUrl?: string | null;
-        order?: number;
-        quizQuestions?: Array<{
-            id: string;
-            material?: string;
-            question?: string;
-            correctWasteTypeId?: string;
-            order?: number;
-            imageUrl?: string | null;
-            kind?: string | null;
-            options?: unknown;
-            explanationText?: string | null;
-            explanationDetailId?: string | null;
-            explanationDetail?: {
-                material?: string | null;
-                description?: string | null;
-                instructions?: string | null;
-            } | null;
-        }>;
-    }>;
-    badge?: {
-        id: string;
-        challengeId: string;
-        name: string;
-        description?: string;
-        icon?: string;
-        imageUrl?: string;
-    } | null;
-};
-
-export type SeriesProgress = {
-    seriesId: string;
-    score: number;
-    completedAt: string;
-};
-
-export type ChallengeSeriesWithProgress = NonNullable<Challenge["series"]>[number] & {
-    progression?: SeriesProgress;
-};
-
-/** `Omit<Challenge, "series">` évite que `series` de `Challenge` écrase le type enrichi. */
-export type ChallengeWithProgress = Omit<Challenge, "series"> & {
-    progression?: UserProgress;
-    series?: ChallengeSeriesWithProgress[];
-};
-
-export type UserProgress = {
-    challengeId: string;
-    challengeName?: string;
-    score?: number;
-    completedAt: string;
-    badge?: Challenge["badge"];
-    series?: SeriesProgress[];
-    [key: string]: unknown;
-};
-
-export type AcquiredBadge = {
-    badgeId: string;
-    challengeId: string;
-    earnedAt: string;
-    badge?: Challenge["badge"];
-};
-
-export type UseChallengesOptions = {
-    /** Conservé pour compat ; le store partagé utilise LocalContext. */
-    cityId?: string | null;
-    pageSize?: number;
-    deviceId?: string | null;
-};
-
-export type UseChallengesResult = {
-    cityId: string | null;
-    challenges: ChallengeWithProgress[];
-    userProgress: UserProgress[];
-    /** Progression indexée par `challengeId` (pratique pour l'affichage). */
-    progressByChallengeId: Record<string, UserProgress>;
-    /** Raccourci pour récupérer la progression d'un challenge. */
-    getProgressByChallengeId: (challengeId: string) => UserProgress | undefined;
-    acquiredBadges: AcquiredBadge[];
-    isLoading: boolean;
-    error: string | null;
-    refetch: () => Promise<void>;
-    getChallengeById: (id: string) => ChallengeWithProgress | undefined;
-};
-
-/**
- * Shared challenges store (via ChallengesProvider inside WastoProvider).
- * Options are ignored — city/device come from LocalContext so all screens stay in sync.
- */
-export function useChallenges(_options: UseChallengesOptions = {}): UseChallengesResult {
-    return useChallengesContext();
-}
+import { useChallengesContext } from "../contexts/ChallengesContext";
+
+export type Challenge = {
+    id: string;
+    name: string;
+    description?: string;
+    imageUrl?: string | null;
+    enabled?: boolean;
+    startDate?: string;
+    endDate?: string;
+    order?: number;
+    requiredChallengeId?: string | null;
+    requiredChallenge?: { id: string; name: string } | null;
+    series?: Array<{
+        id: string;
+        challengeId: string;
+        name: string;
+        description?: string;
+        imageUrl?: string | null;
+        order?: number;
+        quizQuestions?: Array<{
+            id: string;
+            material?: string;
+            question?: string;
+            correctWasteTypeId?: string;
+            order?: number;
+            imageUrl?: string | null;
+            kind?: string | null;
+            options?: unknown;
+            explanationText?: string | null;
+            explanationDetailId?: string | null;
+            explanationDetail?: {
+                material?: string | null;
+                description?: string | null;
+                instructions?: string | null;
+            } | null;
+        }>;
+    }>;
+    badge?: {
+        id: string;
+        challengeId: string;
+        name: string;
+        description?: string;
+        icon?: string;
+        imageUrl?: string;
+    } | null;
+};
+
+export type SeriesProgress = {
+    seriesId: string;
+    score: number;
+    completedAt: string;
+};
+
+export type ChallengeSeriesWithProgress = NonNullable<Challenge["series"]>[number] & {
+    progression?: SeriesProgress;
+};
+
+/** `Omit<Challenge, "series">` évite que `series` de `Challenge` écrase le type enrichi. */
+export type ChallengeWithProgress = Omit<Challenge, "series"> & {
+    progression?: UserProgress;
+    series?: ChallengeSeriesWithProgress[];
+};
+
+export type UserProgress = {
+    challengeId: string;
+    challengeName?: string;
+    score?: number;
+    completedAt: string;
+    badge?: Challenge["badge"];
+    series?: SeriesProgress[];
+    [key: string]: unknown;
+};
+
+export type AcquiredBadge = {
+    badgeId: string;
+    challengeId: string;
+    earnedAt: string;
+    badge?: Challenge["badge"];
+};
+
+export type UseChallengesOptions = {
+    /** Conservé pour compat ; le store partagé utilise LocalContext. */
+    cityId?: string | null;
+    pageSize?: number;
+    deviceId?: string | null;
+};
+
+export type UseChallengesResult = {
+    cityId: string | null;
+    challenges: ChallengeWithProgress[];
+    userProgress: UserProgress[];
+    /** Progression indexée par `challengeId` (pratique pour l'affichage). */
+    progressByChallengeId: Record<string, UserProgress>;
+    /** Raccourci pour récupérer la progression d'un challenge. */
+    getProgressByChallengeId: (challengeId: string) => UserProgress | undefined;
+    acquiredBadges: AcquiredBadge[];
+    isLoading: boolean;
+    error: string | null;
+    refetch: () => Promise<void>;
+    getChallengeById: (id: string) => ChallengeWithProgress | undefined;
+};
+
+/**
+ * Shared challenges store (via ChallengesProvider inside WastoProvider).
+ * Options are ignored — city/device come from LocalContext so all screens stay in sync.
+ */
+export function useChallenges(_options: UseChallengesOptions = {}): UseChallengesResult {
+    return useChallengesContext();
+}

package/src/hooks/useCities.ts

@@ -1,56 +1,56 @@
-import { useCallback, useEffect, useMemo, useState } from "react";
-import { useWastoClient } from "./useWastoClient";
-
-export type City = {
-    id: string;
-    name: string;
-    status?: "NON_ACTIF" | "INCOMPLET" | "ACTIF" | "MAINTENANCE";
-    [key: string]: unknown;
-};
-
-export type UseCitiesResult = {
-    cities: City[];
-    isLoading: boolean;
-    error: string | null;
-    refetch: () => Promise<void>;
-    getCityById: (id: string) => City | undefined;
-};
-
-export type UseCitiesOptions = {
-    pageSize?: number;
-};
-
-export function useCities(options: UseCitiesOptions = {}): UseCitiesResult {
-    const client = useWastoClient();
-
-    const [cities, setCities] = useState<City[]>([]);
-    const [isLoading, setIsLoading] = useState<boolean>(true);
-    const [error, setError] = useState<string | null>(null);
-
-    const pageSize = options.pageSize ?? 100;
-
-    const fetchCities = useCallback(async () => {
-        try {
-            setIsLoading(true);
-            setError(null);
-            const res = await client.public.cities.findAll({ pageSize });
-            const data = (res as { data?: unknown })?.data;
-            setCities(Array.isArray(data) ? (data as City[]) : []);
-        } catch (err) {
-            const message =
-                err instanceof Error ? err.message : typeof err === "string" ? err : "Impossible de charger les villes";
-            setError(message);
-            setCities([]);
-        } finally {
-            setIsLoading(false);
-        }
-    }, [client, pageSize]);
-
-    useEffect(() => {
-        void fetchCities();
-    }, [fetchCities]);
-
-    const getCityById = useCallback((id: string) => cities.find((c) => c.id === id), [cities]);
-
-    return { cities, isLoading, error, refetch: fetchCities, getCityById };
-}
+import { useCallback, useEffect, useMemo, useState } from "react";
+import { useWastoClient } from "./useWastoClient";
+
+export type City = {
+    id: string;
+    name: string;
+    status?: "NON_ACTIF" | "INCOMPLET" | "ACTIF" | "MAINTENANCE";
+    [key: string]: unknown;
+};
+
+export type UseCitiesResult = {
+    cities: City[];
+    isLoading: boolean;
+    error: string | null;
+    refetch: () => Promise<void>;
+    getCityById: (id: string) => City | undefined;
+};
+
+export type UseCitiesOptions = {
+    pageSize?: number;
+};
+
+export function useCities(options: UseCitiesOptions = {}): UseCitiesResult {
+    const client = useWastoClient();
+
+    const [cities, setCities] = useState<City[]>([]);
+    const [isLoading, setIsLoading] = useState<boolean>(true);
+    const [error, setError] = useState<string | null>(null);
+
+    const pageSize = options.pageSize ?? 100;
+
+    const fetchCities = useCallback(async () => {
+        try {
+            setIsLoading(true);
+            setError(null);
+            const res = await client.public.cities.findAll({ pageSize });
+            const data = (res as { data?: unknown })?.data;
+            setCities(Array.isArray(data) ? (data as City[]) : []);
+        } catch (err) {
+            const message =
+                err instanceof Error ? err.message : typeof err === "string" ? err : "Impossible de charger les villes";
+            setError(message);
+            setCities([]);
+        } finally {
+            setIsLoading(false);
+        }
+    }, [client, pageSize]);
+
+    useEffect(() => {
+        void fetchCities();
+    }, [fetchCities]);
+
+    const getCityById = useCallback((id: string) => cities.find((c) => c.id === id), [cities]);
+
+    return { cities, isLoading, error, refetch: fetchCities, getCityById };
+}