@wasto/cms-components 1.5.10

package/src/hooks/useLocations.ts

@@ -0,0 +1,248 @@
+import { useCallback, useEffect, useMemo, useState } from "react";
+import { MAX_PAGE_SIZE } from "@wasto/sdk";
+import { useLocal } from "../contexts/LocalContext";
+import {
+    buildHoursSchedule,
+    type HoursDayRow,
+    type HoursStatus,
+} from "../helpers/hoursSchedule";
+import { useWastoClient } from "./useWastoClient";
+
+export type LocationCategory = "recycling" | "decheterie" | "collection_place" | "sorting_center";
+
+export type MapLocation = {
+    id: string;
+    name: string;
+    category: LocationCategory;
+    address?: string;
+    phone?: string;
+    hoursDisplay?: string;
+    hoursRows?: HoursDayRow[];
+    hoursStatus?: HoursStatus | null;
+    lat: number;
+    lon: number;
+    badges?: string[];
+};
+
+export const LOCATION_CATEGORY_META: Record<
+    LocationCategory,
+    { label: string; color: string }
+> = {
+    recycling: { label: "Points de collecte", color: "#00C2EE" },
+    decheterie: { label: "Déchèteries", color: "#ea580c" },
+    collection_place: { label: "Lieux de ramassage", color: "#7c3aed" },
+    sorting_center: { label: "Centres de tri", color: "#8B00D8" },
+};
+
+export const REUNION_CENTER = { lat: -21.115, lon: 55.53 };
+const PAGE_SIZE = MAX_PAGE_SIZE;
+
+/** GeoJSON order is [lon, lat]. Rejects NaN / out-of-range. */
+export function isValidLatLon(lat: number, lon: number): boolean {
+    return (
+        Number.isFinite(lat) &&
+        Number.isFinite(lon) &&
+        lat >= -90 &&
+        lat <= 90 &&
+        lon >= -180 &&
+        lon <= 180
+    );
+}
+
+function toNumber(value: unknown): number | null {
+    if (typeof value === "number") return Number.isFinite(value) ? value : null;
+    if (typeof value === "string" && value.trim() !== "") {
+        const n = Number(value);
+        return Number.isFinite(n) ? n : null;
+    }
+    return null;
+}
+
+/** Named lon/lat fields — no SVG conversion. */
+function parseLngLat(
+    lonCandidate: unknown,
+    latCandidate: unknown,
+): { lat: number; lon: number } | null {
+    const lon = toNumber(lonCandidate);
+    const lat = toNumber(latCandidate);
+    if (lon == null || lat == null || !isValidLatLon(lat, lon)) return null;
+    return { lat, lon };
+}
+
+/**
+ * Prefer WGS84 latitude/longitude. Legacy coordinateX/Y are aliases
+ * (X = longitude, Y = latitude) already in WGS84 after API migration.
+ */
+function parseRecyclingPointCoords(p: Record<string, unknown>): { lat: number; lon: number } | null {
+    const details =
+        p.details != null && typeof p.details === "object"
+            ? (p.details as Record<string, unknown>)
+            : null;
+
+    const named = parseLngLat(
+        p.longitude ?? p.lon ?? details?.longitude ?? details?.lon,
+        p.latitude ?? p.lat ?? details?.latitude ?? details?.lat,
+    );
+    if (named) return named;
+
+    // Legacy aliases: coordinateX = longitude, coordinateY = latitude
+    return parseLngLat(p.coordinateX, p.coordinateY);
+}
+
+function categorizeRecyclingType(type?: string): LocationCategory {
+    const t = (type ?? "").toLowerCase();
+    if (t.includes("déchèterie") || t.includes("decheterie") || t.includes("dechetterie")) {
+        return "decheterie";
+    }
+    if (t.includes("tri") || t.includes("sorting")) {
+        return "sorting_center";
+    }
+    return "recycling";
+}
+
+function asArray(res: unknown): unknown[] {
+    if (Array.isArray(res)) return res;
+    const data = (res as { data?: unknown })?.data;
+    return Array.isArray(data) ? data : [];
+}
+
+function totalPagesFrom(res: unknown): number {
+    const meta = (res as { meta?: { totalPages?: number } })?.meta;
+    const totalPages = meta?.totalPages;
+    return typeof totalPages === "number" && totalPages >= 1 ? totalPages : 1;
+}
+
+type PaginatedFetcher = (params: { page: number; pageSize: number }) => Promise<unknown>;
+
+async function fetchAllPages(fetchPage: PaginatedFetcher): Promise<unknown[]> {
+    const first = await fetchPage({ page: 1, pageSize: PAGE_SIZE });
+    const items = [...asArray(first)];
+    const totalPages = totalPagesFrom(first);
+
+    for (let page = 2; page <= totalPages; page++) {
+        const res = await fetchPage({ page, pageSize: PAGE_SIZE });
+        items.push(...asArray(res));
+    }
+
+    return items;
+}
+
+export type UseLocationsResult = {
+    locations: MapLocation[];
+    isLoading: boolean;
+    error: string | null;
+    center: { lat: number; lon: number };
+    refetch: () => Promise<void>;
+};
+
+export function useLocations(): UseLocationsResult {
+    const { selectedCityId } = useLocal();
+    const client = useWastoClient();
+
+    const [locations, setLocations] = useState<MapLocation[]>([]);
+    const [isLoading, setIsLoading] = useState(false);
+    const [error, setError] = useState<string | null>(null);
+
+    const fetchLocations = useCallback(async () => {
+        if (!selectedCityId) {
+            setLocations([]);
+            setIsLoading(false);
+            setError(null);
+            return;
+        }
+
+        try {
+            setIsLoading(true);
+            setError(null);
+            const [points, places] = await Promise.all([
+                fetchAllPages((params) =>
+                    client.public.cities.getRecyclingPoints(selectedCityId, params),
+                ),
+                fetchAllPages((params) =>
+                    client.public.cities.getWasteCollectionPlaces(selectedCityId, params),
+                ),
+            ]);
+
+            const out: MapLocation[] = [];
+
+            for (const raw of points) {
+                const p = raw as Record<string, unknown>;
+                const coords = parseRecyclingPointCoords(p);
+                if (!coords) continue;
+                const id = String(p.id ?? "");
+                if (!id) continue;
+                const hoursSource = {
+                    hours: typeof p.hours === "string" ? p.hours : null,
+                    details:
+                        p.details != null && typeof p.details === "object"
+                            ? (p.details as Record<string, unknown>)
+                            : null,
+                };
+                const schedule = buildHoursSchedule(hoursSource);
+                out.push({
+                    id: `rp-${id}`,
+                    name: String(p.name ?? "Point de collecte"),
+                    category: categorizeRecyclingType(typeof p.type === "string" ? p.type : undefined),
+                    address: typeof p.address === "string" ? p.address : undefined,
+                    phone: typeof p.phone === "string" ? p.phone : undefined,
+                    hoursDisplay: schedule.summary ?? undefined,
+                    hoursRows: schedule.rows.length ? schedule.rows : undefined,
+                    hoursStatus: schedule.status,
+                    lat: coords.lat,
+                    lon: coords.lon,
+                    badges: schedule.status ? [schedule.status.text] : schedule.summary ? [schedule.summary] : undefined,
+                });
+            }
+
+            for (const raw of places) {
+                const place = raw as Record<string, unknown>;
+                const locs = Array.isArray(place.attachedLocations) ? place.attachedLocations : [];
+                const loc = locs.find((item) => {
+                    const l = item as Record<string, unknown>;
+                    return l.latitude != null && l.longitude != null;
+                }) as Record<string, unknown> | undefined;
+                if (!loc) continue;
+                const coords = parseLngLat(loc.longitude, loc.latitude);
+                if (!coords) continue;
+                const id = String(place.id ?? loc.id ?? "");
+                if (!id) continue;
+                out.push({
+                    id: `cp-${id}`,
+                    name: String(place.name ?? loc.name ?? "Lieu de ramassage"),
+                    category: "collection_place",
+                    address: typeof loc.reference === "string" ? loc.reference : undefined,
+                    lat: coords.lat,
+                    lon: coords.lon,
+                });
+            }
+
+            setLocations(out);
+        } catch (err) {
+            setError(err instanceof Error ? err.message : "Impossible de charger les lieux");
+            setLocations([]);
+        } finally {
+            setIsLoading(false);
+        }
+    }, [client.public.cities, selectedCityId]);
+
+    useEffect(() => {
+        void fetchLocations();
+    }, [fetchLocations]);
+
+    const center = useMemo(() => {
+        const valid = locations.filter((l) => isValidLatLon(l.lat, l.lon));
+        if (valid.length === 0) return REUNION_CENTER;
+        const lat = valid.reduce((sum, l) => sum + l.lat, 0) / valid.length;
+        const lon = valid.reduce((sum, l) => sum + l.lon, 0) / valid.length;
+        if (!isValidLatLon(lat, lon)) return REUNION_CENTER;
+        return { lat, lon };
+    }, [locations]);
+
+    return {
+        locations,
+        isLoading,
+        error,
+        center,
+        refetch: fetchLocations,
+    };
+}

package/src/hooks/useNextCollection.ts

@@ -0,0 +1,238 @@
+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,
+    };
+}

package/src/hooks/useRecyclingInfo.ts

@@ -0,0 +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,
+    };
+}

package/src/hooks/useWastoClient.ts

@@ -0,0 +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],
+    );
+}