@wasto/cms-components 1.5.10 → 1.5.12

package/src/hooks/useNextCollection.ts

@@ -1,238 +1,163 @@
-import { useCallback, useEffect, useMemo, useState } from "react";
-import { useLocal } from "../contexts/LocalContext";
-import { getContrastColor } from "../helpers/getContrastColor";
-import { useWastoClient } from "./useWastoClient";
-
-export type City = {
-    id: string;
-    name: string;
-    status?: "NON_ACTIF" | "INCOMPLET" | "ACTIF" | "MAINTENANCE";
-    [key: string]: unknown;
-};
-
-export type WasteType = {
-    id: string;
-    name?: string;
-    icon?: string;
-    imageUrl?: string | null;
-    color?: string;
-    [key: string]: unknown;
-};
-
-export type WasteCollectionPlace = {
-    id: string;
-    name?: string;
-    collectionDays?: Array<{
-        /** Ex: "Lundi", "Mardi", ... (mapping lundi=0 … dimanche=6) */
-        name: string;
-        wasteTypeId: string;
-        biweekly?: boolean;
-        startDate?: string;
-    }>;
-    /** Périodes d’exception (pas de collecte) */
-    exceptions?: Array<{ dateFrom: string; dateTo: string }>;
-    [key: string]: unknown;
-};
-
-export type UseNextCollectionOptions = {
-    /** Si omis, on prend `selectedCityId` depuis `LocalContext`. */
-    cityId?: string | null;
-    /** Décalage (en jours) par rapport à aujourd’hui. 0 = aujourd’hui, 1 = demain, etc. */
-    dateOffset?: number;
-    /** Lieu de collecte sélectionné. Si omis : 1er lieu disponible. */
-    selectedPlaceId?: string | null;
-    pageSize?: number;
-};
-
-export type CollectionForDay = {
-    id: string;
-    name: string;
-    icon?: string;
-    imageUrl?: string | null;
-    color?: string;
-    contrastColor?: "#000000" | "#FFFFFF";
-};
-
-export type UseNextCollectionResult = {
-    cityId: string | null;
-    city: City | null;
-    wasteTypes: WasteType[];
-    wasteCollectionPlaces: WasteCollectionPlace[];
-    /** Décalage (en jours) utilisé pour calculer `collectionsForDay`. */
-    dateOffset: number;
-    /** Libellé “HIER / AUJOURD’HUI / DEMAIN / Dans N jour(s)” */
-    dateLabel: string;
-    /** Types de déchets collectés pour ce jour (vide si aucune collecte) */
-    collectionsForDay: CollectionForDay[];
-    isLoading: boolean;
-    error: string | null;
-    refetch: () => Promise<void>;
-};
-
-const DAY_MAPPING: Record<string, number> = {
-    Dimanche: 6,
-    Lundi: 0,
-    Mardi: 1,
-    Mercredi: 2,
-    Jeudi: 3,
-    Vendredi: 4,
-    Samedi: 5,
-};
-
-function getDateLabel(offset: number): string {
-    if (offset === -1) return "hier";
-    if (offset === 0) return "Aujourd'hui";
-    if (offset === 1) return "Demain";
-    return offset < 0 ? `Il y a ${Math.abs(offset)} jours` : `Dans ${offset} jours`;
-}
-
-function getCollectionsForDay(
-    wasteTypes: WasteType[],
-    wasteCollectionPlaces: WasteCollectionPlace[],
-    dateOffset: number,
-    selectedPlaceId?: string | null
-): CollectionForDay[] {
-    if (!wasteCollectionPlaces?.length) return [];
-
-    const place = selectedPlaceId
-        ? wasteCollectionPlaces.find((p) => p.id === selectedPlaceId) ?? wasteCollectionPlaces[0]
-        : wasteCollectionPlaces[0];
-
-    const schedule = place?.collectionDays ?? [];
-    const exceptions = place?.exceptions ?? [];
-
-    const targetDate = new Date();
-    targetDate.setDate(targetDate.getDate() + dateOffset);
-    const dayOfWeek = targetDate.getDay();
-    const mondayBasedDay = dayOfWeek === 0 ? 6 : dayOfWeek - 1;
-
-    const results: CollectionForDay[] = [];
-    const seen = new Set<string>();
-
-    for (const day of schedule) {
-        if (DAY_MAPPING[day.name] !== mondayBasedDay) continue;
-
-        const hasException = exceptions.some((exc) => {
-            const from = new Date(exc.dateFrom + "T00:00:00");
-            const to = new Date(exc.dateTo + "T00:00:00");
-            return targetDate.getTime() >= from.getTime() && targetDate.getTime() < to.getTime();
-        });
-        if (hasException) continue;
-
-        if (day.biweekly && day.startDate) {
-            const start = new Date(day.startDate);
-            const diffDays = Math.floor(
-                (targetDate.getTime() - start.getTime()) / (1000 * 60 * 60 * 24)
-            );
-            const weeks = Math.floor(diffDays / 7);
-            if (weeks < 0 || weeks % 2 !== 0) continue;
-        }
-
-        const wt = wasteTypes.find((w) => w.id === day.wasteTypeId);
-        if (!wt) continue;
-
-        if (seen.has(wt.id)) continue;
-        seen.add(wt.id);
-
-        results.push({
-            id: wt.id,
-            name: wt.name ?? "",
-            icon: typeof wt.icon === "string" ? wt.icon : undefined,
-            imageUrl: typeof wt.imageUrl === "string" ? wt.imageUrl : undefined,
-            color: typeof wt.color === "string" ? wt.color : undefined,
-            contrastColor:
-                typeof wt.color === "string" && wt.color.trim()
-                    ? getContrastColor(wt.color.trim())
-                    : undefined,
-        });
-    }
-
-    return results;
-}
-
-/**
- * Récupère les données nécessaires pour afficher le bloc "Prochaine collecte":
- * - ville
- * - types de déchets
- * - lieux de collecte
- *
- * Le calcul exact de la "prochaine collecte" dépend du modèle de calendrier côté API
- * et sera fait par le composant (ou un util) à partir des `wasteTypes`/`wasteCollectionPlaces`.
- */
-export function useNextCollection(options: UseNextCollectionOptions = {}): UseNextCollectionResult {
-    const { selectedCityId, selectedPlaceId: localPlaceId } = useLocal();
-
-    const resolvedCityId = options.cityId ?? selectedCityId ?? null;
-    const pageSize = options.pageSize ?? 100;
-    const dateOffset = options.dateOffset ?? 0;
-    const selectedPlaceId = options.selectedPlaceId ?? localPlaceId ?? null;
-
-    const client = useWastoClient();
-
-    const [city, setCity] = useState<City | null>(null);
-    const [wasteTypes, setWasteTypes] = useState<WasteType[]>([]);
-    const [wasteCollectionPlaces, setWasteCollectionPlaces] = useState<WasteCollectionPlace[]>([]);
-    const [isLoading, setIsLoading] = useState<boolean>(false);
-    const [error, setError] = useState<string | null>(null);
-
-    const fetchData = useCallback(async () => {
-        if (!resolvedCityId) {
-            setCity(null);
-            setWasteTypes([]);
-            setWasteCollectionPlaces([]);
-            setIsLoading(false);
-            setError(null);
-            return;
-        }
-
-        try {
-            setIsLoading(true);
-            setError(null);
-
-            const [cityRes, typesRes, placesRes] = await Promise.all([
-                client.public.cities.getById(resolvedCityId),
-                client.public.cities.getWasteTypes(resolvedCityId, { pageSize }),
-                client.public.cities.getWasteCollectionPlaces(resolvedCityId, { pageSize }),
-            ]);
-
-            setCity((cityRes ?? null) as City | null);
-
-            const types = (typesRes as { data?: unknown })?.data;
-            setWasteTypes(Array.isArray(types) ? (types as WasteType[]) : []);
-
-            const places = (placesRes as { data?: unknown })?.data;
-            setWasteCollectionPlaces(Array.isArray(places) ? (places as WasteCollectionPlace[]) : []);
-        } catch (err) {
-            const message =
-                err instanceof Error ? err.message : typeof err === "string" ? err : "Impossible de charger les données";
-            setError(message);
-            setCity(null);
-            setWasteTypes([]);
-            setWasteCollectionPlaces([]);
-        } finally {
-            setIsLoading(false);
-        }
-    }, [client.public.cities, pageSize, resolvedCityId]);
-
-    useEffect(() => {
-        void fetchData();
-    }, [fetchData]);
-
-    const collectionsForDay = useMemo(
-        () => getCollectionsForDay(wasteTypes, wasteCollectionPlaces, dateOffset, selectedPlaceId),
-        [wasteTypes, wasteCollectionPlaces, dateOffset, selectedPlaceId]
-    );
-
-    return {
-        cityId: resolvedCityId,
-        city,
-        wasteTypes,
-        wasteCollectionPlaces,
-        dateOffset,
-        dateLabel: getDateLabel(dateOffset),
-        collectionsForDay,
-        isLoading,
-        error,
-        refetch: fetchData,
-    };
-}
+import { useCallback, useEffect, useMemo, useState } from "react";
+import { useLocal } from "../contexts/LocalContext";
+import {
+    NEXT_EVENTS_DAY_RADIUS,
+    useOptionalAppData,
+} from "../contexts/AppDataContext";
+import { useWastoClient } from "./useWastoClient";
+import {
+    getCollectionsForDay,
+    getDateLabel,
+    type City,
+    type CollectionForDay,
+    type WasteCollectionPlace,
+    type WasteType,
+} from "../helpers/nextCollection";
+
+export type {
+    City,
+    WasteType,
+    WasteCollectionPlace,
+    CollectionForDay,
+} from "../helpers/nextCollection";
+
+export { getCollectionsForDay, getDateLabel } from "../helpers/nextCollection";
+
+export type UseNextCollectionOptions = {
+    /** Si omis, on prend `selectedCityId` depuis `LocalContext`. */
+    cityId?: string | null;
+    /** Décalage (en jours) par rapport à aujourd’hui. 0 = aujourd’hui, 1 = demain, etc. */
+    dateOffset?: number;
+    /** Lieu de collecte sélectionné. Si omis : 1er lieu disponible. */
+    selectedPlaceId?: string | null;
+    pageSize?: number;
+};
+
+export type UseNextCollectionResult = {
+    cityId: string | null;
+    city: City | null;
+    wasteTypes: WasteType[];
+    wasteCollectionPlaces: WasteCollectionPlace[];
+    /** Décalage (en jours) utilisé pour calculer `collectionsForDay`. */
+    dateOffset: number;
+    /** Libellé “HIER / AUJOURD’HUI / DEMAIN / Dans N jour(s)” */
+    dateLabel: string;
+    /** Types de déchets collectés pour ce jour (vide si aucune collecte) */
+    collectionsForDay: CollectionForDay[];
+    isLoading: boolean;
+    error: string | null;
+    refetch: () => Promise<void>;
+};
+
+/**
+ * Récupère les données nécessaires pour afficher le bloc "Prochaine collecte":
+ * - ville
+ * - types de déchets
+ * - lieux de collecte
+ *
+ * Préfère le cache partagé `AppDataProvider` (preload API) quand disponible.
+ */
+export function useNextCollection(options: UseNextCollectionOptions = {}): UseNextCollectionResult {
+    const { selectedCityId, selectedPlaceId: localPlaceId } = useLocal();
+    const appData = useOptionalAppData();
+
+    const resolvedCityId = options.cityId ?? selectedCityId ?? null;
+    const pageSize = options.pageSize ?? 100;
+    const dateOffset = options.dateOffset ?? 0;
+    const selectedPlaceId = options.selectedPlaceId ?? localPlaceId ?? null;
+
+    const client = useWastoClient();
+
+    const [city, setCity] = useState<City | null>(null);
+    const [wasteTypes, setWasteTypes] = useState<WasteType[]>([]);
+    const [wasteCollectionPlaces, setWasteCollectionPlaces] = useState<WasteCollectionPlace[]>([]);
+    const [isLoading, setIsLoading] = useState<boolean>(false);
+    const [error, setError] = useState<string | null>(null);
+
+    const useShared =
+        Boolean(appData) &&
+        (options.cityId == null ||
+            options.cityId === appData?.city?.id ||
+            options.cityId === selectedCityId);
+
+    const fetchData = useCallback(async () => {
+        if (useShared && appData) {
+            return;
+        }
+
+        if (!resolvedCityId) {
+            setCity(null);
+            setWasteTypes([]);
+            setWasteCollectionPlaces([]);
+            setIsLoading(false);
+            setError(null);
+            return;
+        }
+
+        try {
+            setIsLoading(true);
+            setError(null);
+
+            const [cityRes, typesRes, placesRes] = await Promise.all([
+                client.public.cities.getById(resolvedCityId),
+                client.public.cities.getWasteTypes(resolvedCityId, { pageSize }),
+                client.public.cities.getWasteCollectionPlaces(resolvedCityId, { pageSize }),
+            ]);
+
+            setCity((cityRes ?? null) as City | null);
+
+            const types = (typesRes as { data?: unknown })?.data;
+            setWasteTypes(Array.isArray(types) ? (types as WasteType[]) : []);
+
+            const places = (placesRes as { data?: unknown })?.data;
+            setWasteCollectionPlaces(Array.isArray(places) ? (places as WasteCollectionPlace[]) : []);
+        } catch (err) {
+            const message =
+                err instanceof Error
+                    ? err.message
+                    : typeof err === "string"
+                      ? err
+                      : "Impossible de charger les données";
+            setError(message);
+            setCity(null);
+            setWasteTypes([]);
+            setWasteCollectionPlaces([]);
+        } finally {
+            setIsLoading(false);
+        }
+    }, [appData, client.public.cities, pageSize, resolvedCityId, useShared]);
+
+    useEffect(() => {
+        void fetchData();
+    }, [fetchData]);
+
+    const sharedWasteTypes = useShared && appData ? appData.wasteTypes : wasteTypes;
+    const sharedPlaces = useShared && appData ? appData.wasteCollectionPlaces : wasteCollectionPlaces;
+    const sharedCity = useShared && appData ? appData.city : city;
+
+    const collectionsForDay = useMemo(() => {
+        if (
+            useShared &&
+            appData &&
+            dateOffset >= -NEXT_EVENTS_DAY_RADIUS &&
+            dateOffset <= NEXT_EVENTS_DAY_RADIUS &&
+            appData.nextEventsByOffset[dateOffset]
+        ) {
+            return appData.nextEventsByOffset[dateOffset];
+        }
+        return getCollectionsForDay(sharedWasteTypes, sharedPlaces, dateOffset, selectedPlaceId);
+    }, [appData, dateOffset, selectedPlaceId, sharedPlaces, sharedWasteTypes, useShared]);
+
+    return {
+        cityId: resolvedCityId,
+        city: sharedCity,
+        wasteTypes: sharedWasteTypes,
+        wasteCollectionPlaces: sharedPlaces,
+        dateOffset,
+        dateLabel: getDateLabel(dateOffset),
+        collectionsForDay,
+        isLoading: useShared && appData ? appData.isBootstrapping : isLoading,
+        error: useShared && appData ? appData.scheduleError : error,
+        refetch: useShared && appData ? appData.refreshSchedule : fetchData,
+    };
+}

package/src/hooks/useRecyclingInfo.ts

@@ -1,90 +1,90 @@
-import { useMemo } from "react";
-import { useLocal } from "../contexts/LocalContext";
-import {
-    normalizeWasteTypeToRecyclingInfo,
-    type RecyclingInfoItem,
-} from "../helpers/normalizeWasteTypeRecyclingInfo";
-import { useNextCollection, type City, type WasteType } from "./useNextCollection";
-
-export type { RecyclingInfoItem };
-
-export type UseRecyclingInfoOptions = {
-    /** Si omis, utilise `LocalContext.selectedCityId`. */
-    cityId?: string | null;
-    /**
-     * Si renseigné : ne renvoie que ce type de déchet.
-     * Sinon : renvoie la liste complète des types pour la ville.
-     */
-    wasteTypeId?: string | null;
-    pageSize?: number;
-};
-
-export type UseRecyclingInfoResult = {
-    cityId: string | null;
-    city: City | null;
-    wasteTypes: WasteType[];
-    /** Liste filtrée selon `wasteTypeId` (ou `wasteTypes` si pas de filtre). */
-    displayWasteTypes: WasteType[];
-    /**
-     * Infos de tri / recyclage normalisées (règles, détails, etc.) pour chaque type affiché.
-     * Préférer ce tableau pour l’UI plutôt que `displayWasteTypes` seul.
-     */
-    recyclingInfos: RecyclingInfoItem[];
-    isLoading: boolean;
-    error: string | null;
-    refetch: () => Promise<void>;
-    getWasteTypeById: (id: string) => WasteType | undefined;
-};
-
-/**
- * Hook utilitaire pour le composant `RecyclingInfo`.
- * Il s’appuie sur `useNextCollection` pour récupérer la ville et les wasteTypes,
- * puis applique un filtre optionnel par `wasteTypeId`.
- */
-export function useRecyclingInfo(options: UseRecyclingInfoOptions = {}): UseRecyclingInfoResult {
-    const { selectedCityId } = useLocal();
-    const resolvedCityId = options.cityId ?? selectedCityId ?? null;
-
-    const {
-        city,
-        wasteTypes,
-        isLoading,
-        error,
-        refetch,
-        cityId,
-    } = useNextCollection({
-        cityId: resolvedCityId,
-        pageSize: options.pageSize,
-    });
-
-    const wasteTypesList = useMemo(() => (wasteTypes ?? []) as WasteType[], [wasteTypes]);
-    const filterId = (options.wasteTypeId ?? "").trim();
-
-    const displayWasteTypes = useMemo(() => {
-        if (!filterId) return wasteTypesList;
-        return wasteTypesList.filter((w) => w.id === filterId);
-    }, [wasteTypesList, filterId]);
-
-    const recyclingInfos = useMemo(() => {
-        const list: RecyclingInfoItem[] = [];
-        for (const w of displayWasteTypes) {
-            const item = normalizeWasteTypeToRecyclingInfo(w);
-            if (item) list.push(item);
-        }
-        return list;
-    }, [displayWasteTypes]);
-
-    const getWasteTypeById = (id: string) => wasteTypesList.find((w) => w.id === id);
-
-    return {
-        cityId,
-        city,
-        wasteTypes: wasteTypesList,
-        displayWasteTypes,
-        recyclingInfos,
-        isLoading,
-        error,
-        refetch,
-        getWasteTypeById,
-    };
-}
+import { useMemo } from "react";
+import { useLocal } from "../contexts/LocalContext";
+import {
+    normalizeWasteTypeToRecyclingInfo,
+    type RecyclingInfoItem,
+} from "../helpers/normalizeWasteTypeRecyclingInfo";
+import { useNextCollection, type City, type WasteType } from "./useNextCollection";
+
+export type { RecyclingInfoItem };
+
+export type UseRecyclingInfoOptions = {
+    /** Si omis, utilise `LocalContext.selectedCityId`. */
+    cityId?: string | null;
+    /**
+     * Si renseigné : ne renvoie que ce type de déchet.
+     * Sinon : renvoie la liste complète des types pour la ville.
+     */
+    wasteTypeId?: string | null;
+    pageSize?: number;
+};
+
+export type UseRecyclingInfoResult = {
+    cityId: string | null;
+    city: City | null;
+    wasteTypes: WasteType[];
+    /** Liste filtrée selon `wasteTypeId` (ou `wasteTypes` si pas de filtre). */
+    displayWasteTypes: WasteType[];
+    /**
+     * Infos de tri / recyclage normalisées (règles, détails, etc.) pour chaque type affiché.
+     * Préférer ce tableau pour l’UI plutôt que `displayWasteTypes` seul.
+     */
+    recyclingInfos: RecyclingInfoItem[];
+    isLoading: boolean;
+    error: string | null;
+    refetch: () => Promise<void>;
+    getWasteTypeById: (id: string) => WasteType | undefined;
+};
+
+/**
+ * Hook utilitaire pour le composant `RecyclingInfo`.
+ * Il s’appuie sur `useNextCollection` pour récupérer la ville et les wasteTypes,
+ * puis applique un filtre optionnel par `wasteTypeId`.
+ */
+export function useRecyclingInfo(options: UseRecyclingInfoOptions = {}): UseRecyclingInfoResult {
+    const { selectedCityId } = useLocal();
+    const resolvedCityId = options.cityId ?? selectedCityId ?? null;
+
+    const {
+        city,
+        wasteTypes,
+        isLoading,
+        error,
+        refetch,
+        cityId,
+    } = useNextCollection({
+        cityId: resolvedCityId,
+        pageSize: options.pageSize,
+    });
+
+    const wasteTypesList = useMemo(() => (wasteTypes ?? []) as WasteType[], [wasteTypes]);
+    const filterId = (options.wasteTypeId ?? "").trim();
+
+    const displayWasteTypes = useMemo(() => {
+        if (!filterId) return wasteTypesList;
+        return wasteTypesList.filter((w) => w.id === filterId);
+    }, [wasteTypesList, filterId]);
+
+    const recyclingInfos = useMemo(() => {
+        const list: RecyclingInfoItem[] = [];
+        for (const w of displayWasteTypes) {
+            const item = normalizeWasteTypeToRecyclingInfo(w);
+            if (item) list.push(item);
+        }
+        return list;
+    }, [displayWasteTypes]);
+
+    const getWasteTypeById = (id: string) => wasteTypesList.find((w) => w.id === id);
+
+    return {
+        cityId,
+        city,
+        wasteTypes: wasteTypesList,
+        displayWasteTypes,
+        recyclingInfos,
+        isLoading,
+        error,
+        refetch,
+        getWasteTypeById,
+    };
+}

package/src/hooks/useWastoClient.ts

@@ -1,16 +1,16 @@
-import { useMemo } from "react";
-import { createWastoClient, type WastoClient } from "@wasto/sdk";
-import { useWasto } from "../contexts/WastoContext";
-
-/** Shared Wasto HTTP client wired with optional API error reporting. */
-export function useWastoClient(): WastoClient {
-    const { apiUrl, onRequestError } = useWasto();
-    return useMemo(
-        () =>
-            createWastoClient({
-                baseUrl: apiUrl,
-                onRequestError,
-            }),
-        [apiUrl, onRequestError],
-    );
-}
+import { useMemo } from "react";
+import { createWastoClient, type WastoClient } from "@wasto/sdk";
+import { useWasto } from "../contexts/WastoContext";
+
+/** Shared Wasto HTTP client wired with optional API error reporting. */
+export function useWastoClient(): WastoClient {
+    const { apiUrl, onRequestError } = useWasto();
+    return useMemo(
+        () =>
+            createWastoClient({
+                baseUrl: apiUrl,
+                onRequestError,
+            }),
+        [apiUrl, onRequestError],
+    );
+}