@wasto/cms-components 1.5.10 → 1.5.12

package/src/hooks/useColumns.ts

@@ -1,20 +1,20 @@
-import { useMemo } from "react";
-
-export function useColumns<T = any>(
-    data: T[],
-    itemsPerRow: number = 4,
-): (T | null)[][] {
-    return useMemo(() => {
-        const rows: (T | null)[][] = [];
-
-        for (let i = 0; i < data.length; i += itemsPerRow) {
-            const row: (T | null)[] = data.slice(i, i + itemsPerRow);
-            while (row.length < itemsPerRow) {
-                row.push(null);
-            }
-            rows.push(row);
-        }
-
-        return rows;
-    }, [data]);
+import { useMemo } from "react";
+
+export function useColumns<T = any>(
+    data: T[],
+    itemsPerRow: number = 4,
+): (T | null)[][] {
+    return useMemo(() => {
+        const rows: (T | null)[][] = [];
+
+        for (let i = 0; i < data.length; i += itemsPerRow) {
+            const row: (T | null)[] = data.slice(i, i + itemsPerRow);
+            while (row.length < itemsPerRow) {
+                row.push(null);
+            }
+            rows.push(row);
+        }
+
+        return rows;
+    }, [data]);
 }

package/src/hooks/useConsignes.ts

@@ -1,62 +1,62 @@
-import { useMemo } from "react";
-import { normalizeWasteTypeToRecyclingInfo } from "../helpers/normalizeWasteTypeRecyclingInfo";
-import { useNextCollection } from "./useNextCollection";
-
-export type WasteTypeForConsignes = {
-    name: string;
-    imageUrl?: string;
-    rules?: string[];
-    color?: string;
-    details?: Array<{
-        id: string | number;
-        material?: string;
-        description?: string;
-        imageUrl?: string;
-    }>;
-};
-
-export type CityForConsignes = {
-    general_collection_rules?: Record<string, string>;
-    [key: string]: unknown;
-};
-
-export type UseConsignesResult = {
-    currentCity: CityForConsignes | null;
-    wasteType: WasteTypeForConsignes | null;
-    isLoading: boolean;
-    error: string | null;
-};
-
-/**
- * Prépare les données pour la modale de consignes à partir de:
- * - la ville courante (useNextCollection.city)
- * - la liste des wasteTypes (useNextCollection.wasteTypes)
- */
-export function useConsignes(wasteTypeId: string | null | undefined): UseConsignesResult {
-    const { city, wasteTypes, isLoading, error } = useNextCollection();
-
-    const wasteType = useMemo<WasteTypeForConsignes | null>(() => {
-        if (!wasteTypeId) return null;
-
-        const wt = (wasteTypes ?? []).find((w) => w.id === wasteTypeId);
-        if (!wt) return null;
-
-        const info = normalizeWasteTypeToRecyclingInfo(wt);
-        if (!info) return null;
-
-        return {
-            name: info.name,
-            imageUrl: info.imageUrl,
-            rules: info.rules,
-            details: info.details,
-            color: info.color
-        };
-    }, [wasteTypeId, wasteTypes]);
-
-    return {
-        currentCity: (city as any) ?? null,
-        wasteType,
-        isLoading,
-        error,
-    };
-}
+import { useMemo } from "react";
+import { normalizeWasteTypeToRecyclingInfo } from "../helpers/normalizeWasteTypeRecyclingInfo";
+import { useNextCollection } from "./useNextCollection";
+
+export type WasteTypeForConsignes = {
+    name: string;
+    imageUrl?: string;
+    rules?: string[];
+    color?: string;
+    details?: Array<{
+        id: string | number;
+        material?: string;
+        description?: string;
+        imageUrl?: string;
+    }>;
+};
+
+export type CityForConsignes = {
+    general_collection_rules?: Record<string, string>;
+    [key: string]: unknown;
+};
+
+export type UseConsignesResult = {
+    currentCity: CityForConsignes | null;
+    wasteType: WasteTypeForConsignes | null;
+    isLoading: boolean;
+    error: string | null;
+};
+
+/**
+ * Prépare les données pour la modale de consignes à partir de:
+ * - la ville courante (useNextCollection.city)
+ * - la liste des wasteTypes (useNextCollection.wasteTypes)
+ */
+export function useConsignes(wasteTypeId: string | null | undefined): UseConsignesResult {
+    const { city, wasteTypes, isLoading, error } = useNextCollection();
+
+    const wasteType = useMemo<WasteTypeForConsignes | null>(() => {
+        if (!wasteTypeId) return null;
+
+        const wt = (wasteTypes ?? []).find((w) => w.id === wasteTypeId);
+        if (!wt) return null;
+
+        const info = normalizeWasteTypeToRecyclingInfo(wt);
+        if (!info) return null;
+
+        return {
+            name: info.name,
+            imageUrl: info.imageUrl,
+            rules: info.rules,
+            details: info.details,
+            color: info.color
+        };
+    }, [wasteTypeId, wasteTypes]);
+
+    return {
+        currentCity: (city as any) ?? null,
+        wasteType,
+        isLoading,
+        error,
+    };
+}

package/src/hooks/useLocations.ts

@@ -1,248 +1,120 @@
-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,
-    };
-}
+import { useCallback, useEffect, useMemo, useState } from "react";
+import { MAX_PAGE_SIZE } from "@wasto/sdk";
+import { useLocal } from "../contexts/LocalContext";
+import { useOptionalAppData } from "../contexts/AppDataContext";
+import {
+    computeMapCenter,
+    isValidLatLon,
+    LOCATION_CATEGORY_META,
+    normalizeMapLocations,
+    REUNION_CENTER,
+    type LocationCategory,
+    type MapLocation,
+} from "../helpers/mapLocations";
+import { useWastoClient } from "./useWastoClient";
+
+export type { LocationCategory, MapLocation };
+export { LOCATION_CATEGORY_META, REUNION_CENTER, isValidLatLon };
+
+const PAGE_SIZE = MAX_PAGE_SIZE;
+
+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 appData = useOptionalAppData();
+    const client = useWastoClient();
+
+    const [locations, setLocations] = useState<MapLocation[]>([]);
+    const [isLoading, setIsLoading] = useState(false);
+    const [error, setError] = useState<string | null>(null);
+
+    const useShared = Boolean(appData);
+
+    const fetchLocations = useCallback(async () => {
+        if (useShared && appData) {
+            await appData.refreshCachedData();
+            return;
+        }
+
+        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),
+                ),
+            ]);
+
+            setLocations(normalizeMapLocations(points, places));
+        } catch (err) {
+            setError(err instanceof Error ? err.message : "Impossible de charger les lieux");
+            setLocations([]);
+        } finally {
+            setIsLoading(false);
+        }
+    }, [appData, client.public.cities, selectedCityId, useShared]);
+
+    useEffect(() => {
+        if (useShared) return;
+        void fetchLocations();
+    }, [fetchLocations, useShared]);
+
+    const sharedLocations = useShared && appData ? appData.locations : locations;
+    const center = useMemo(
+        () =>
+            useShared && appData ? appData.mapCenter : computeMapCenter(sharedLocations),
+        [appData, sharedLocations, useShared],
+    );
+
+    return {
+        locations: sharedLocations,
+        isLoading: useShared && appData ? appData.isMapLoading : isLoading,
+        error: useShared && appData ? appData.mapError : error,
+        center,
+        refetch: fetchLocations,
+    };
+}