@wasto/cms-components 1.5.10

package/src/helpers/hoursSchedule.ts

@@ -0,0 +1,230 @@
+import {
+    WEEKDAYS,
+    WEEKDAY_LABELS_FR,
+    formatOpeningHoursWeekly,
+    formatTimeDisplay,
+    getBrowserTimeZone,
+    parseTimeMinutes,
+    resolveHoursDisplay,
+    resolveHoursText,
+    resolveOpeningHoursUtc,
+    type TimeSlot,
+    type Weekday,
+} from "@wasto/sdk";
+
+export type HoursDayRow = {
+    label: string;
+    hours: string;
+    closed: boolean;
+};
+
+export type HoursStatus = {
+    open: boolean;
+    text: string;
+};
+
+export type HoursSchedule = {
+    rows: HoursDayRow[];
+    status: HoursStatus | null;
+    summary: string | null;
+};
+
+const DAY_ALIASES: Record<string, Weekday> = {
+    lun: "monday",
+    lundi: "monday",
+    mar: "tuesday",
+    mardi: "tuesday",
+    mer: "wednesday",
+    mercredi: "wednesday",
+    jeu: "thursday",
+    jeudi: "thursday",
+    ven: "friday",
+    vendredi: "friday",
+    sam: "saturday",
+    samedi: "saturday",
+    dim: "sunday",
+    dimanche: "sunday",
+};
+
+function parseTimeToken(raw: string): string | null {
+    const m = raw.trim().match(/^(\d{1,2})(?:[h:](\d{2}))?$/i);
+    if (!m) return null;
+    const h = Number(m[1]);
+    const min = m[2] ? Number(m[2]) : 0;
+    if (h > 24 || min > 59) return null;
+    const hours = Math.min(h, 23);
+    return `${String(hours).padStart(2, "0")}:${String(min).padStart(2, "0")}`;
+}
+
+function formatSlotDisplay(slot: TimeSlot): string {
+    const fmt = (hhmm: string) => {
+        const [h, m] = hhmm.split(":").map(Number);
+        return `${h}:${String(m).padStart(2, "0")}`;
+    };
+    return `${fmt(slot.open)} - ${fmt(slot.close)}`;
+}
+
+function emptyByDay(): Map<Weekday, TimeSlot[]> {
+    const byDay = new Map<Weekday, TimeSlot[]>();
+    for (const day of WEEKDAYS) byDay.set(day, []);
+    return byDay;
+}
+
+function rowsFromByDay(byDay: Map<Weekday, TimeSlot[]>): HoursDayRow[] {
+    return WEEKDAYS.map((day) => {
+        const slots = byDay.get(day) ?? [];
+        return {
+            label: WEEKDAY_LABELS_FR[day],
+            hours: slots.length ? slots.map(formatSlotDisplay).join(", ") : "Fermé",
+            closed: slots.length === 0,
+        };
+    });
+}
+
+function weekdayFromLocalDate(at: Date): Weekday {
+    const jsDay = at.getDay();
+    return WEEKDAYS[(jsDay + 6) % 7]!;
+}
+
+function statusFromByDay(
+    byDay: Map<Weekday, TimeSlot[]>,
+    at = new Date(),
+): HoursStatus | null {
+    const hasAny = WEEKDAYS.some((day) => (byDay.get(day) ?? []).length > 0);
+    if (!hasAny) return null;
+
+    const weekday = weekdayFromLocalDate(at);
+    const nowMin = at.getHours() * 60 + at.getMinutes();
+    const todaySlots = byDay.get(weekday) ?? [];
+
+    for (const slot of todaySlots) {
+        const open = parseTimeMinutes(slot.open);
+        const close = parseTimeMinutes(slot.close);
+        if (open == null || close == null) continue;
+        if (nowMin >= open && nowMin < close) {
+            return { open: true, text: `Ouvert - Ferme à ${formatTimeDisplay(slot.close)}` };
+        }
+    }
+
+    const startIdx = WEEKDAYS.indexOf(weekday);
+    for (let i = 0; i < 7; i++) {
+        const day = WEEKDAYS[(startIdx + i) % 7]!;
+        const daySlots = byDay.get(day) ?? [];
+        for (const slot of daySlots) {
+            const open = parseTimeMinutes(slot.open);
+            if (open == null) continue;
+            if (i === 0 && open <= nowMin) continue;
+            const openLabel = formatTimeDisplay(slot.open);
+            if (i === 0) return { open: false, text: `Fermé - Ouvre à ${openLabel}` };
+            return {
+                open: false,
+                text: `Fermé - Ouvre ${WEEKDAY_LABELS_FR[day]} à ${openLabel}`,
+            };
+        }
+    }
+
+    return { open: false, text: "Fermé" };
+}
+
+function applyDayRange(
+    byDay: Map<Weekday, TimeSlot[]>,
+    from: Weekday,
+    to: Weekday,
+    slot: TimeSlot,
+) {
+    const startIdx = WEEKDAYS.indexOf(from);
+    const endIdx = WEEKDAYS.indexOf(to);
+    if (startIdx < 0 || endIdx < 0) return;
+    for (let i = startIdx; ; i = (i + 1) % 7) {
+        byDay.set(WEEKDAYS[i]!, [slot]);
+        if (i === endIdx) break;
+    }
+}
+
+function parseTextHours(text: string): Map<Weekday, TimeSlot[]> | null {
+    const t = text.trim();
+    if (!t) return null;
+    const byDay = emptyByDay();
+
+    if (/24\s*h?\s*\/\s*24/i.test(t) || /^24\s*h/i.test(t)) {
+        for (const day of WEEKDAYS) byDay.set(day, [{ open: "00:00", close: "23:59" }]);
+        return byDay;
+    }
+
+    const timeRe = /(\d{1,2})(?:[:h](\d{2}))?h?\s*[-–à]\s*(\d{1,2})(?:[:h](\d{2}))?h?/i;
+    const timeMatch = t.match(timeRe);
+    if (!timeMatch || timeMatch.index == null) return null;
+
+    const open = parseTimeToken(`${timeMatch[1]}h${timeMatch[2] ?? "00"}`);
+    const close = parseTimeToken(`${timeMatch[3]}h${timeMatch[4] ?? "00"}`);
+    if (!open || !close) return null;
+    const slot: TimeSlot = { open, close };
+
+    const dayPart = t.slice(0, timeMatch.index);
+    const dayRe =
+        /(lundi|mardi|mercredi|jeudi|vendredi|samedi|dimanche|lun|mar|mer|jeu|ven|sam|dim)\.?\b/gi;
+    const daysFound: Weekday[] = [];
+    let match: RegExpExecArray | null;
+    while ((match = dayRe.exec(dayPart)) !== null) {
+        const raw = match[1].toLowerCase();
+        const day = DAY_ALIASES[raw] ?? DAY_ALIASES[raw.slice(0, 3)];
+        if (day) daysFound.push(day);
+    }
+
+    if (daysFound.length === 0) {
+        for (const day of WEEKDAYS) byDay.set(day, [slot]);
+        return byDay;
+    }
+
+    if (daysFound.length >= 2 && /[-–à]/.test(dayPart)) {
+        applyDayRange(byDay, daysFound[0]!, daysFound[1]!, slot);
+        return byDay;
+    }
+
+    for (const day of daysFound) byDay.set(day, [slot]);
+    return byDay;
+}
+
+function byDayFromWeekly(
+    weekly: ReturnType<typeof formatOpeningHoursWeekly>,
+): Map<Weekday, TimeSlot[]> {
+    const byDay = emptyByDay();
+    for (const row of weekly) {
+        byDay.set(row.day, row.closed ? [] : row.slots);
+    }
+    return byDay;
+}
+
+export function buildHoursSchedule(point: {
+    hours?: string | null;
+    details?: Record<string, unknown> | null;
+}): HoursSchedule {
+    const utc = resolveOpeningHoursUtc(point);
+    if (utc) {
+        const weekly = formatOpeningHoursWeekly(utc, getBrowserTimeZone());
+        const byDay = byDayFromWeekly(weekly);
+        return {
+            rows: weekly.map((row) => ({
+                label: row.label,
+                hours: row.closed ? "Fermé" : row.slots.map(formatSlotDisplay).join(", "),
+                closed: row.closed,
+            })),
+            status: statusFromByDay(byDay),
+            summary: resolveHoursDisplay(point),
+        };
+    }
+
+    const text =
+        resolveHoursText(point) ??
+        (typeof point.hours === "string" && point.hours.trim() ? point.hours.trim() : null);
+    if (!text) return { rows: [], status: null, summary: null };
+
+    const parsed = parseTextHours(text);
+    if (!parsed) return { rows: [], status: null, summary: text };
+
+    return {
+        rows: rowsFromByDay(parsed),
+        status: statusFromByDay(parsed),
+        summary: text,
+    };
+}

package/src/helpers/htmlContentToMarkdown.ts

@@ -0,0 +1,114 @@
+const HTML_HINT =
+    /<(table|thead|tbody|tr|td|th|p|div|h[1-6]|ul|ol|li|blockquote|pre|u|ins|strong|em|img|br)\b/i;
+
+export function looksLikeHtml(content: string): boolean {
+    return HTML_HINT.test(content);
+}
+
+function decodeEntities(value: string): string {
+    return value
+        .replace(/&nbsp;/gi, " ")
+        .replace(/&amp;/g, "&")
+        .replace(/&lt;/g, "<")
+        .replace(/&gt;/g, ">")
+        .replace(/&quot;/g, '"')
+        .replace(/&#39;/g, "'");
+}
+
+function stripTags(html: string): string {
+    return decodeEntities(
+        html
+            .replace(/<br\s*\/?>/gi, "\n")
+            .replace(/<\/p>/gi, "\n")
+            .replace(/<[^>]+>/g, "")
+            .replace(/\s+\n/g, "\n")
+            .replace(/\n\s+/g, "\n")
+            .replace(/[ \t]+/g, " ")
+            .trim(),
+    );
+}
+
+function cellText(html: string): string {
+    return stripTags(html).replace(/\n/g, " ").replace(/\|/g, "\\|");
+}
+
+export function htmlTableToGfm(tableHtml: string): string {
+    const rows = [...tableHtml.matchAll(/<tr[\s\S]*?<\/tr>/gi)].map((row) =>
+        [...row[0].matchAll(/<t[hd][\s\S]*?<\/t[hd]>/gi)].map((cell) => cellText(cell[0])),
+    );
+    if (rows.length === 0) return "";
+    const width = Math.max(...rows.map((r) => r.length), 1);
+    const padded = rows.map((r) => [...r, ...Array.from({ length: width - r.length }, () => "")]);
+    const header = padded[0];
+    const sep = header.map(() => "---");
+    return [
+        `| ${header.join(" | ")} |`,
+        `| ${sep.join(" | ")} |`,
+        ...padded.slice(1).map((r) => `| ${r.join(" | ")} |`),
+    ].join("\n");
+}
+
+function convertInline(html: string): string {
+    return html
+        .replace(/<(strong|b)>([\s\S]*?)<\/\1>/gi, "**$2**")
+        .replace(/<(em|i)>([\s\S]*?)<\/\1>/gi, "*$2*")
+        .replace(/<(u|ins)>([\s\S]*?)<\/\1>/gi, "++$2++")
+        .replace(/<code>([\s\S]*?)<\/code>/gi, "`$1`")
+        .replace(/<a\b[^>]*href=["']([^"']+)["'][^>]*>([\s\S]*?)<\/a>/gi, "[$2]($1)")
+        .replace(/<img\b[^>]*alt=["']([^"']*)["'][^>]*src=["']([^"']+)["'][^>]*\/?>/gi, "![$1]($2)")
+        .replace(/<img\b[^>]*src=["']([^"']+)["'][^>]*alt=["']([^"']*)["'][^>]*\/?>/gi, "![$2]($1)")
+        .replace(/<img\b[^>]*src=["']([^"']+)["'][^>]*\/?>/gi, "![]($1)")
+        .replace(/<br\s*\/?>/gi, "  \n");
+}
+
+/**
+ * Converts leaked / legacy HTML (especially Tiptap tables and underline) to GFM.
+ * Safe to run on mixed Markdown + HTML.
+ */
+export function htmlContentToMarkdown(content: string): string {
+    if (!content || !looksLikeHtml(content)) return content;
+
+    let out = content.replace(
+        /<div[^>]*class="[^"]*tableWrapper[^"]*"[^>]*>([\s\S]*?)<\/div>/gi,
+        "$1",
+    );
+    out = out.replace(/<table[\s\S]*?<\/table>/gi, (table) => `\n\n${htmlTableToGfm(table)}\n\n`);
+    out = out.replace(/<(u|ins)>([\s\S]*?)<\/\1>/gi, "++$2++");
+
+    if (!looksLikeHtml(out)) {
+        return out.replace(/\n{3,}/g, "\n\n").trim();
+    }
+
+    out = out.replace(/<h([1-3])[^>]*>([\s\S]*?)<\/h\1>/gi, (_m, level: string, inner: string) => {
+        return `\n\n${"#".repeat(Number(level))} ${stripTags(convertInline(inner))}\n\n`;
+    });
+    out = out.replace(/<blockquote[^>]*>([\s\S]*?)<\/blockquote>/gi, (_m, inner: string) => {
+        const body = stripTags(convertInline(inner))
+            .split("\n")
+            .map((line) => `> ${line}`)
+            .join("\n");
+        return `\n\n${body}\n\n`;
+    });
+    out = out.replace(/<pre[^>]*><code[^>]*>([\s\S]*?)<\/code><\/pre>/gi, (_m, inner: string) => {
+        return `\n\n\`\`\`\n${decodeEntities(inner).replace(/<\/?code>/gi, "").trim()}\n\`\`\`\n\n`;
+    });
+    out = out.replace(/<ul[^>]*>([\s\S]*?)<\/ul>/gi, (_m, inner: string) => {
+        const items = [...String(inner).matchAll(/<li[^>]*>([\s\S]*?)<\/li>/gi)].map(
+            (item) => `- ${stripTags(convertInline(item[1]))}`,
+        );
+        return `\n\n${items.join("\n")}\n\n`;
+    });
+    out = out.replace(/<ol[^>]*>([\s\S]*?)<\/ol>/gi, (_m, inner: string) => {
+        const items = [...String(inner).matchAll(/<li[^>]*>([\s\S]*?)<\/li>/gi)].map(
+            (item, i) => `${i + 1}. ${stripTags(convertInline(item[1]))}`,
+        );
+        return `\n\n${items.join("\n")}\n\n`;
+    });
+    out = out.replace(/<p[^>]*>([\s\S]*?)<\/p>/gi, (_m, inner: string) => {
+        return `\n\n${stripTags(convertInline(inner))}\n\n`;
+    });
+    out = convertInline(out);
+    out = out.replace(/<\/?(div|span|tbody|thead|tfoot)[^>]*>/gi, "");
+    out = stripTags(out);
+    return out.replace(/\n{3,}/g, "\n\n").trim();
+}

package/src/helpers/layout.ts

@@ -0,0 +1,54 @@
+/**
+ * Layout tokens from `.idea/maquette/00-tokens-et-style.md`.
+ * Structural spacing only — colors/radii come from Theme (CMS custom).
+ */
+export const SPACE = {
+    /** Horizontal padding for text / section content */
+    pageX: 16,
+    /** Tighter horizontal (search, chips, CTA bottom) */
+    pageXTight: 12,
+    /** Vertical gap between section header and content */
+    sectionY: 24,
+    /** Internal card / challenge row padding */
+    cardPad: 20,
+    /** Stack gap between list rows */
+    stack: 12,
+    /** Primary button height */
+    buttonH: 42,
+    /** Round icon hit target */
+    iconHit: 34,
+    /** Glyph inside icon hit */
+    iconGlyph: 18,
+    /** Approx. tab bar content height (excl. safe area) */
+    tabBarH: 86,
+    /** Next-collection card height (maquette ~196) */
+    collectionCardH: 196,
+    /** Next-collection card width target */
+    collectionCardW: 286,
+} as const;
+
+/** Suggested radii when building a maquette-aligned Theme (defaults, not hardcoded in UI). */
+export const MAQUETTE_RADII = {
+    sm: 12,
+    md: 16,
+    lg: 24,
+    pill: 999,
+    radius: 20,
+} as const;
+
+export const MAQUETTE_COLORS = {
+    background: "#F5F5F5",
+    surface: "#FFFFFF",
+    onSurface: "#090909",
+    onBackground: "#090909",
+    primary: "#00D100",
+    onPrimary: "#FFFFFF",
+    primarySoft: "#A6ECA6",
+    muted: "#9A9A9A",
+    border: "#E5E5E5",
+    success: "#FEEA16",
+    onSuccess: "#090909",
+    error: "#D16602",
+    onError: "#FFFFFF",
+    surfaceElevated: "#FFFFFF",
+} as const;

package/src/helpers/loadLinearGradient.ts

@@ -0,0 +1,22 @@
+type LinearGradientComponent = typeof import("expo-linear-gradient").LinearGradient;
+
+/**
+ * Load LinearGradient only when the native ExpoLinearGradient module is available.
+ * Returns null otherwise so callers can fall back to a solid View / color
+ * (avoids RN "Component not implemented…").
+ */
+export function loadLinearGradient(): LinearGradientComponent | null {
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        const { requireOptionalNativeModule } = require("expo-modules-core");
+        if (!requireOptionalNativeModule("ExpoLinearGradient")) {
+            return null;
+        }
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        return require("expo-linear-gradient").LinearGradient as LinearGradientComponent;
+    } catch {
+        return null;
+    }
+}
+
+export const LinearGradientOrNull = loadLinearGradient();

package/src/helpers/maquetteTheme.ts

@@ -0,0 +1,76 @@
+import type { Theme } from "../types/Theme";
+import { MAQUETTE_COLORS, MAQUETTE_RADII } from "./layout";
+
+/**
+ * Default theme aligned with `.idea/maquette` tokens.
+ * Runtime apps override via CMS `config.theme` (console).
+ */
+export function createMaquetteTheme(overrides?: Partial<Theme>): Theme {
+    const base: Theme = {
+        colors: {
+            primary: MAQUETTE_COLORS.primary,
+            onPrimary: MAQUETTE_COLORS.onPrimary,
+            surface: MAQUETTE_COLORS.surface,
+            onSurface: MAQUETTE_COLORS.onSurface,
+            background: MAQUETTE_COLORS.background,
+            onBackground: MAQUETTE_COLORS.onBackground,
+            success: MAQUETTE_COLORS.success,
+            onSuccess: MAQUETTE_COLORS.onSuccess,
+            error: MAQUETTE_COLORS.error,
+            onError: MAQUETTE_COLORS.onError,
+            border: MAQUETTE_COLORS.border,
+            primarySoft: MAQUETTE_COLORS.primarySoft,
+            surfaceElevated: MAQUETTE_COLORS.surfaceElevated,
+            muted: MAQUETTE_COLORS.muted,
+            gradient: {
+                from: MAQUETTE_COLORS.primary,
+                to: MAQUETTE_COLORS.primarySoft,
+            },
+        },
+        radius: MAQUETTE_RADII.radius,
+        radii: {
+            sm: MAQUETTE_RADII.sm,
+            md: MAQUETTE_RADII.md,
+            lg: MAQUETTE_RADII.lg,
+            pill: MAQUETTE_RADII.pill,
+        },
+        shadow: {
+            card: {
+                shadowColor: "#0F172A",
+                shadowOffset: { width: 0, height: 1 },
+                shadowOpacity: 0.06,
+                shadowRadius: 3,
+                elevation: 1,
+            },
+            soft: {
+                shadowColor: "#0F172A",
+                shadowOffset: { width: 0, height: 1 },
+                shadowOpacity: 0.04,
+                shadowRadius: 2,
+                elevation: 1,
+            },
+        },
+    };
+
+    if (!overrides) return base;
+
+    return {
+        ...base,
+        ...overrides,
+        colors: {
+            ...base.colors,
+            ...overrides.colors,
+            gradient: {
+                ...base.colors.gradient,
+                ...overrides.colors?.gradient,
+            },
+        },
+        radii: overrides.radii ? { ...base.radii!, ...overrides.radii } : base.radii,
+        shadow: overrides.shadow
+            ? {
+                  card: { ...base.shadow!.card, ...overrides.shadow.card },
+                  soft: { ...base.shadow!.soft, ...overrides.shadow.soft },
+              }
+            : base.shadow,
+    };
+}

package/src/helpers/markdownUnderlinePlugin.ts

@@ -0,0 +1,32 @@
+/**
+ * Parses `++text++` as underline (`ins`), matching Console Turndown output.
+ */
+export function markdownUnderlinePlugin(md: {
+    inline: {
+        ruler: {
+            after: (name: string, ruleName: string, fn: (state: any, silent: boolean) => boolean) => void;
+        };
+    };
+}): void {
+    md.inline.ruler.after("emphasis", "underline", (state: any, silent: boolean) => {
+        if (
+            state.src.charCodeAt(state.pos) !== 0x2b ||
+            state.src.charCodeAt(state.pos + 1) !== 0x2b
+        ) {
+            return false;
+        }
+        const close = state.src.indexOf("++", state.pos + 2);
+        if (close < state.pos + 2) return false;
+        if (silent) return true;
+
+        const content = state.src.slice(state.pos + 2, close);
+        const open = state.push("ins_open", "ins", 1);
+        open.markup = "++";
+        const text = state.push("text", "", 0);
+        text.content = content;
+        const end = state.push("ins_close", "ins", -1);
+        end.markup = "++";
+        state.pos = close + 2;
+        return true;
+    });
+}

package/src/helpers/normalizeWasteTypeRecyclingInfo.ts

@@ -0,0 +1,80 @@
+import type { WasteType } from "../hooks/useNextCollection";
+
+export type RecyclingInfoDetail = {
+    id: string | number;
+    material?: string;
+    description?: string;
+    imageUrl?: string;
+};
+
+export type RecyclingInfoItem = {
+    id: string;
+    /** Alias explicite de `id` (utile côté UI/props). */
+    wasteTypeId: string;
+    name: string;
+    description?: string;
+    icon?: string;
+    imageUrl?: string;
+    color?: string;
+    colorLight?: string;
+    rules?: string[];
+    details?: RecyclingInfoDetail[];
+};
+
+export function normalizeWasteTypeToRecyclingInfo(wt: WasteType): RecyclingInfoItem | null {
+    const id = typeof wt?.id === "string" ? wt.id : null;
+    if (!id) return null;
+
+    const extended = wt as WasteType & {
+        description?: unknown;
+        colorLight?: unknown;
+        details?: unknown;
+        rules?: unknown;
+        imageUrl?: unknown;
+    };
+
+    const detailsRaw = extended.details;
+    const details = Array.isArray(detailsRaw)
+        ? detailsRaw
+              .map((raw: unknown, idx: number) => {
+                  const d = raw && typeof raw === "object" ? (raw as Record<string, unknown>) : {};
+                  const rid = d.id;
+                  const detailId =
+                      typeof rid === "string" || typeof rid === "number" ? rid : `${id}-${idx}`;
+                  const imageUrl =
+                      typeof d.imageUrl === "string" && d.imageUrl.trim()
+                          ? d.imageUrl.trim()
+                          : undefined;
+                  return {
+                      id: detailId,
+                      material: typeof d.material === "string" ? d.material : undefined,
+                      description: typeof d.description === "string" ? d.description : undefined,
+                      imageUrl,
+                  };
+              })
+              .filter((d) => d.material || d.description || d.imageUrl)
+        : undefined;
+
+    const rulesRaw = extended.rules;
+    const rules = Array.isArray(rulesRaw)
+        ? rulesRaw.filter((r): r is string => typeof r === "string" && r.trim().length > 0)
+        : undefined;
+
+    const imageUrl =
+        typeof extended.imageUrl === "string" && extended.imageUrl.trim()
+            ? extended.imageUrl.trim()
+            : undefined;
+
+    return {
+        id,
+        wasteTypeId: id,
+        name: typeof wt.name === "string" ? wt.name : "",
+        description: typeof extended.description === "string" ? extended.description : undefined,
+        icon: typeof wt.icon === "string" ? wt.icon : undefined,
+        imageUrl,
+        color: typeof wt.color === "string" ? wt.color : undefined,
+        colorLight: typeof extended.colorLight === "string" ? extended.colorLight : undefined,
+        rules,
+        details,
+    };
+}

package/src/helpers/publicMediaUrl.ts

@@ -0,0 +1,8 @@
+export function publicMediaUrl(
+    apiUrl: string,
+    mediaId: string | null | undefined
+): string | null {
+    const id = (mediaId ?? "").trim();
+    if (!id) return null;
+    return `${apiUrl.replace(/\/$/, "")}/public/cms/media/${encodeURIComponent(id)}/file`;
+}

package/src/helpers/resolveApiAssetUrl.ts

@@ -0,0 +1,21 @@
+/** Résout une URL d’asset API (chemin `/public/...` ou URL absolue / data:). */
+export function resolveApiAssetUrl(
+    apiUrl: string,
+    url: string | null | undefined,
+): string | null {
+    const v = (url ?? "").trim();
+    if (!v) return null;
+    if (
+        v.startsWith("data:") ||
+        v.startsWith("http://") ||
+        v.startsWith("https://") ||
+        v.startsWith("file:") ||
+        v.startsWith("blob:")
+    ) {
+        return v;
+    }
+    if (v.startsWith("/")) {
+        return `${apiUrl.replace(/\/$/, "")}${v}`;
+    }
+    return v;
+}

package/src/helpers/systemRoutes.ts

@@ -0,0 +1,7 @@
+/** Fixed Expo Router paths for shell screens (apps générées + playground). */
+export const SYSTEM_ROUTES = {
+    notifications: "/(system)/notifications",
+    profile: "/(system)/profile",
+} as const;
+
+export type SystemRouteKey = keyof typeof SYSTEM_ROUTES;