@lastbrain/app 2.0.31 → 2.0.35

package/dist/scripts/module-create.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"module-create.d.ts","sourceRoot":"","sources":["../../src/scripts/module-create.ts"],"names":[],"mappings":"AASA,MAAM,WAAW,UAAU;IACzB,OAAO,EAAE,QAAQ,GAAG,MAAM,GAAG,OAAO,CAAC;IACrC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,CAAC,QAAQ,GAAG,MAAM,GAAG,OAAO,CAAC,EAAE,CAAC;CAC3C;AAED,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,UAAU,EAAE,CAAC;IACpB,MAAM,EAAE,WAAW,EAAE,CAAC;IACtB,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AA61CD;;GAEG;AACH,wBAAgB,iBAAiB,IAAI,MAAM,CAiB1C;AAED;;GAEG;AACH,wBAAsB,qBAAqB,CACzC,MAAM,EAAE,YAAY,EACpB,OAAO,EAAE,MAAM,iBA2MhB;AAED;;GAEG;AACH,wBAAsB,YAAY,kBAuOjC"}
+{"version":3,"file":"module-create.d.ts","sourceRoot":"","sources":["../../src/scripts/module-create.ts"],"names":[],"mappings":"AASA,MAAM,WAAW,UAAU;IACzB,OAAO,EAAE,QAAQ,GAAG,MAAM,GAAG,OAAO,CAAC;IACrC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,CAAC,QAAQ,GAAG,MAAM,GAAG,OAAO,CAAC,EAAE,CAAC;CAC3C;AAED,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,UAAU,EAAE,CAAC;IACpB,MAAM,EAAE,WAAW,EAAE,CAAC;IACtB,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAu2CD;;GAEG;AACH,wBAAgB,iBAAiB,IAAI,MAAM,CAiB1C;AAoLD;;GAEG;AACH,wBAAsB,qBAAqB,CACzC,MAAM,EAAE,YAAY,EACpB,OAAO,EAAE,MAAM,iBAyQhB;AAED;;GAEG;AACH,wBAAsB,YAAY,kBAuOjC"}

package/dist/scripts/module-create.js

@@ -28,13 +28,14 @@ function parsePagesList(input) {
 }
 /**
  * Slugifie un nom de page: minuscules, tirets, alphanum uniquement
+ * Préserve les crochets [] pour les routes dynamiques et les slashes / pour les sous-chemins
  */
 function slugifyPageName(name) {
     return name
         .trim()
         .toLowerCase()
         .replace(/[\s_]+/g, "-")
-        .replace(/[^a-z0-9-]/g, "")
+        .replace(/[^a-z0-9\-/[\]]/g, "") // Préserve -, /, [, ]
         .replace(/--+/g, "-")
         .replace(/^-+|-+$/g, "");
 }
@@ -75,7 +76,7 @@ function getLastBrainPackageVersions(rootDir) {
  */
 function generatePackageJson(moduleName, slug, rootDir, isPro = false) {
     const versions = getLastBrainPackageVersions(rootDir);
-    const moduleNameOnly = slug.replace("module-", "").replace("-pro", "");
+    const moduleNameOnly = slug.replace("module-", "");
     const buildConfigExport = `./${moduleNameOnly}.build.config`;
     const packageJson = {
         name: moduleName,
@@ -329,7 +330,7 @@ function toPascalCase(value) {
         .map((w) => w.charAt(0).toUpperCase() + w.slice(1))
         .join("");
 }
-function generateIndexTs(pages, moduleNameOnly) {
+function generateIndexTs(pages, moduleNameOnly, hasPublicPages) {
     // Grouper les pages par nom pour détecter les doublons
     const pagesByName = new Map();
     for (const page of pages) {
@@ -351,6 +352,10 @@ function generateIndexTs(pages, moduleNameOnly) {
     // Nettoyer le nom pour l'alias d'export (enlever -pro si présent)
     const cleanedNameOnly = moduleNameOnly.replace(/-pro$/, "");
     const moduleAlias = toPascalCase(cleanedNameOnly);
+    // Export du sitemap manifest si le module a des pages publiques
+    const sitemapExport = hasPublicPages
+        ? `\n// Sitemap configuration\nexport { sitemapManifest } from "./sitemap/manifest";\n`
+        : "";
     return `// Client Components
 ${exports.join("\n")}
 
@@ -359,7 +364,7 @@ export { Doc } from "./components/Doc";
 export { Doc as ${moduleAlias}ModuleDoc } from "./components/Doc";
 
 // Configuration de build
-export { default as buildConfig } from "./${moduleNameOnly}.build.config";
+export { default as buildConfig } from "./${moduleNameOnly}.build.config";${sitemapExport}
 `;
 }
 /**
@@ -1223,6 +1228,182 @@ export function findWorkspaceRoot() {
     }
     throw new Error("Impossible de trouver le répertoire racine du workspace (pnpm-workspace.yaml non trouvé)");
 }
+/**
+ * Génère le fichier manifest.ts pour les sitemaps
+ */
+function generateSitemapManifest(moduleName) {
+    return `/**
+ * Types pour le système de sitemaps multi-modules
+ */
+export type SitemapChildKind = "static" | "reexport";
+
+export interface SitemapChild {
+  id: string;
+  path: string;
+  kind: SitemapChildKind;
+  handler?: string;
+  paging?: {
+    pageSize: number;
+  };
+}
+
+export interface SitemapManifest {
+  module: string;
+  enabled: boolean;
+  includePublicPagesFromBuildConfig: boolean;
+  children: SitemapChild[];
+}
+
+/**
+ * Manifest des sitemaps du module ${moduleName}
+ * Déclare tous les sitemaps enfants à générer
+ * 
+ * Configuration:
+ * - enabled: Active/désactive le module dans les sitemaps globaux
+ * - includePublicPagesFromBuildConfig: Inclut automatiquement les pages publiques du build.config
+ * - children: Liste des sitemaps à générer
+ * 
+ * Types de sitemaps:
+ * 1. "static": Pages statiques générées depuis build.config (sans paramètres dynamiques)
+ * 2. "reexport": Sitemaps dynamiques avec handler personnalisé (avec paramètres :lang, :type, etc.)
+ */
+export const sitemapManifest: SitemapManifest = {
+  module: "${moduleName}",
+  enabled: true,
+  includePublicPagesFromBuildConfig: true,
+  children: [
+    // Pages statiques (générées automatiquement depuis build.config)
+    {
+      id: "static",
+      path: ":lang/static.xml",
+      kind: "static",
+    },
+    
+    // EXEMPLE: Sitemap dynamique avec handler personnalisé
+    // Décommentez et adaptez selon vos besoins:
+    
+    // {
+    //   id: "dynamic-content",
+    //   path: ":lang/content.xml",
+    //   kind: "reexport",
+    //   handler: "${moduleName}/sitemap/handlers/content",
+    // },
+  ],
+} as const;
+`;
+}
+/**
+ * Génère un exemple de handler de sitemap dynamique
+ */
+function generateSitemapHandler(moduleName) {
+    return `/**
+ * EXEMPLE: Handler dynamique pour sitemap
+ * 
+ * Ce fichier montre comment créer un sitemap dynamique qui génère
+ * des URLs à partir de données (base de données, API, liste statique, etc.)
+ * 
+ * Pour activer ce handler:
+ * 1. Décommentez l'entrée correspondante dans manifest.ts
+ * 2. Adaptez la logique ci-dessous à vos besoins
+ * 3. Rebuild le module: pnpm --filter ${moduleName} build
+ */
+
+import { LOCALE_MAP } from "@lastbrain/core";
+// Pour récupérer des données depuis Supabase:
+// import { getSupabaseServiceClient } from "@lastbrain/core/server";
+
+/**
+ * Handler GET pour générer le sitemap XML
+ * 
+ * @param _request - Requête HTTP (non utilisée ici)
+ * @param context - Contient les paramètres dynamiques de la route (:lang, :type, etc.)
+ * @returns Response avec le XML du sitemap
+ */
+export async function GET(
+  _request: Request,
+  context: { params: Promise<{ lang: string }> }
+): Promise<Response> {
+  const params = await context.params;
+  const { lang } = params;
+
+  // Validation de la langue
+  if (!LOCALE_MAP[lang]) {
+    return new Response("Invalid language", { status: 404 });
+  }
+
+  // Configuration de l'URL de base
+  const baseUrl =
+    process.env.NEXT_PUBLIC_SITE_URL ||
+    (process.env.VERCEL_URL
+      ? \`https://\${process.env.VERCEL_URL}\`
+      : "https://example.com");
+
+  try {
+    // EXEMPLE 1: Liste statique d'URLs
+    const staticItems = [
+      { slug: "item-1", updatedAt: new Date().toISOString() },
+      { slug: "item-2", updatedAt: new Date().toISOString() },
+      { slug: "item-3", updatedAt: new Date().toISOString() },
+    ];
+
+    // EXEMPLE 2: Récupération depuis Supabase (décommentez si besoin)
+    /*
+    const supabase = getSupabaseServiceClient();
+    const { data: items, error } = await supabase
+      .from("your_table")
+      .select("slug, updated_at")
+      .eq("status", "published")
+      .order("updated_at", { ascending: false })
+      .limit(1000);
+
+    if (error) {
+      console.error("Sitemap error:", error);
+      return new Response(JSON.stringify({ error: error.message }), {
+        status: 500,
+        headers: { "Content-Type": "application/json" },
+      });
+    }
+    */
+
+    // Génération des URLs pour le sitemap
+    const urls = staticItems.map((item) => ({
+      url: \`\${baseUrl}/\${lang}/your-section/\${item.slug}\`,
+      lastmod: item.updatedAt,
+      changefreq: "weekly",
+      priority: 0.7,
+    }));
+
+    // Construction du XML
+    const urlEntries = urls
+      .map(
+        (entry) => \`  <url>
+    <loc>\${entry.url}</loc>
+    <lastmod>\${entry.lastmod}</lastmod>
+    <changefreq>\${entry.changefreq}</changefreq>
+    <priority>\${entry.priority}</priority>
+  </url>\`
+      )
+      .join("\\n");
+
+    const xml = \`<?xml version="1.0" encoding="UTF-8"?>
+<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+\${urlEntries}
+</urlset>\`;
+
+    // Retour de la réponse XML
+    return new Response(xml, {
+      headers: {
+        "Content-Type": "application/xml",
+        "Cache-Control": "public, max-age=3600",
+      },
+    });
+  } catch (err) {
+    console.error("Sitemap generation error:", err);
+    return new Response("Internal error", { status: 500 });
+  }
+}
+`;
+}
 /**
  * Crée la structure du module
  */
@@ -1248,9 +1429,11 @@ export async function createModuleStructure(config, rootDir) {
     const buildConfigFileName = `${moduleNameOnly}.build.config.ts`;
     console.log(chalk.yellow(`  📄 src/${buildConfigFileName}`));
     await fs.writeFile(path.join(moduleDir, "src", buildConfigFileName), generateBuildConfig(config));
+    // Détecter si le module a des pages publiques (pour l'export sitemap)
+    const hasPublicPages = config.pages.some((p) => p.section === "public");
     // Créer index.ts
     console.log(chalk.yellow("  📄 src/index.ts"));
-    await fs.writeFile(path.join(moduleDir, "src", "index.ts"), generateIndexTs(config.pages, moduleNameOnly));
+    await fs.writeFile(path.join(moduleDir, "src", "index.ts"), generateIndexTs(config.pages, moduleNameOnly, hasPublicPages));
     // Note: server.ts n'est plus généré pour éviter les conflits d'exports
     // Les routes API sont exposées via le build.config et l'app les importe dynamiquement
     // Créer Doc.tsx
@@ -1267,20 +1450,38 @@ export async function createModuleStructure(config, rootDir) {
         pagesByName.set(key, existing);
     }
     for (const page of config.pages) {
-        const pagePath = path.join(moduleDir, "src", "web", page.section);
+        // Extraire le chemin du répertoire et le nom de base de la page
+        const pageNameParts = page.name.split("/");
+        const pageBaseName = pageNameParts[pageNameParts.length - 1];
+        // Créer le chemin complet incluant les sous-répertoires avec leurs noms originaux
+        // Garder les noms tels quels (ex: "apis", "[slug]" etc.) pour les répertoires
+        const subdirParts = pageNameParts.slice(0, -1);
+        const pagePath = subdirParts.length > 0
+            ? path.join(moduleDir, "src", "web", page.section, ...subdirParts)
+            : path.join(moduleDir, "src", "web", page.section);
         await fs.ensureDir(pagePath);
-        const baseName = page.name
+        // Le nom de fichier suit la convention Next.js : garder les crochets
+        // apis/[slug] → apis/[slug].tsx
+        // apis/[id]/versions → apis/[id]/versions.tsx
+        const fileName = `${pageBaseName}.tsx`;
+        // Pour le nom du composant React, on enlève les crochets
+        // [slug] → Slug, [id] → Id
+        const cleanedBaseName = pageBaseName.replace(/[[\]]/g, "");
+        const baseName = cleanedBaseName
             .split("-")
             .map((w) => w.charAt(0).toUpperCase() + w.slice(1))
             .join("");
-        // Si le même nom de page existe dans plusieurs sections, ajouter la section au nom du fichier
+        // Si le même nom de page existe dans plusieurs sections, ajouter la section au nom du composant
         const duplicates = pagesByName.get(page.name) || [];
         const hasDuplicates = duplicates.length > 1;
         const componentNameWithSection = hasDuplicates
             ? `${baseName}${toPascalCase(page.section)}`
             : baseName;
-        const fileName = `${componentNameWithSection}Page.tsx`;
-        console.log(chalk.yellow(`  📄 src/web/${page.section}/${fileName}`));
+        // Afficher le chemin complet
+        const fullDisplayPath = subdirParts.length > 0
+            ? `src/web/${page.section}/${subdirParts.join("/")}/${fileName}`
+            : `src/web/${page.section}/${fileName}`;
+        console.log(chalk.yellow(`  📄 ${fullDisplayPath}`));
         await fs.writeFile(path.join(pagePath, fileName), generatePageComponent(page.name, page.section, componentNameWithSection));
     }
     // Créer les routes API
@@ -1315,6 +1516,22 @@ export async function createModuleStructure(config, rootDir) {
         console.log(chalk.yellow(`  📄 supabase/migrations-down/${downFileName}`));
         await fs.writeFile(path.join(moduleDir, "supabase", "migrations-down", downFileName), `-- DOWN migration for ${config.slug}\n${downContent}`);
     }
+    // Créer les fichiers sitemap si le module a des pages publiques
+    if (hasPublicPages) {
+        console.log(chalk.blue("\n🗺️  Création des fichiers sitemap..."));
+        const sitemapDir = path.join(moduleDir, "src", "sitemap");
+        const handlersDir = path.join(sitemapDir, "handlers");
+        await fs.ensureDir(handlersDir);
+        // manifest.ts
+        console.log(chalk.yellow("  📄 src/sitemap/manifest.ts"));
+        await fs.writeFile(path.join(sitemapDir, "manifest.ts"), generateSitemapManifest(config.slug.replace("module-", "")));
+        // Exemple de handler dynamique (commenté par défaut)
+        console.log(chalk.yellow("  📄 src/sitemap/handlers/example.ts (commented)"));
+        await fs.writeFile(path.join(handlersDir, "example.ts"), generateSitemapHandler(config.moduleName));
+        console.log(chalk.green("  ✓ Fichiers sitemap créés"));
+        console.log(chalk.gray("    → Éditez manifest.ts pour personnaliser vos sitemaps"));
+        console.log(chalk.gray("    → Décommentez handlers/example.ts pour ajouter des sitemaps dynamiques"));
+    }
     // Générer la documentation du module
     console.log(chalk.blue("\n📝 Génération de la documentation..."));
     await generateModuleReadme(config, moduleDir);

package/dist/scripts/sitemap-flat-generator.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Générateur de sitemap PLAT (pas d'imbrication d'index)
+ *
+ * PRINCIPE:
+ * - /sitemap.xml = unique index racine
+ * - /sitemap/{module}/{lang}/{type}.xml = sitemaps de contenu (urlset)
+ * - PAS d'index intermédiaire /sitemap/{module}/sitemap.xml
+ *
+ * Conforme aux recommandations Google Search Console :
+ * "Un sitemap index ne doit pas référencer un autre sitemap index"
+ */
+import type { ModuleBuildConfig } from "../index.js";
+interface SitemapEntry {
+    path: string;
+    module: string;
+    kind: string;
+}
+/**
+ * Collecte tous les sitemaps enfants (urlset) de tous les modules
+ * Sans créer d'index intermédiaires
+ */
+export declare function collectAllContentSitemaps(moduleManifests: Array<{
+    config: ModuleBuildConfig;
+    manifest: any;
+}>, languages: string[], appDirectory?: string): SitemapEntry[];
+/**
+ * Génère le sitemap.xml racine PLAT qui liste directement tous les sitemaps de contenu
+ * SANS passer par des index intermédiaires
+ */
+export declare function generateFlatGlobalSitemapIndex(appDirectory: string, entries: SitemapEntry[], isDebugMode: boolean): string;
+/**
+ * Valide qu'aucun sitemap de contenu ne contient de référence circulaire ou imbrication
+ */
+export declare function validateNoNestedIndexes(appDirectory: string, entries: SitemapEntry[], isDebugMode: boolean): {
+    valid: boolean;
+    errors: string[];
+};
+export {};
+//# sourceMappingURL=sitemap-flat-generator.d.ts.map

package/dist/scripts/sitemap-flat-generator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sitemap-flat-generator.d.ts","sourceRoot":"","sources":["../../src/scripts/sitemap-flat-generator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAIH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAErD,UAAU,YAAY;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;CACd;AA6DD;;;GAGG;AACH,wBAAgB,yBAAyB,CACvC,eAAe,EAAE,KAAK,CAAC;IACrB,MAAM,EAAE,iBAAiB,CAAC;IAC1B,QAAQ,EAAE,GAAG,CAAC;CACf,CAAC,EACF,SAAS,EAAE,MAAM,EAAE,EACnB,YAAY,CAAC,EAAE,MAAM,GACpB,YAAY,EAAE,CAwFhB;AAED;;;GAGG;AACH,wBAAgB,8BAA8B,CAC5C,YAAY,EAAE,MAAM,EACpB,OAAO,EAAE,YAAY,EAAE,EACvB,WAAW,EAAE,OAAO,UAyDrB;AAED;;GAEG;AACH,wBAAgB,uBAAuB,CACrC,YAAY,EAAE,MAAM,EACpB,OAAO,EAAE,YAAY,EAAE,EACvB,WAAW,EAAE,OAAO,GACnB;IAAE,KAAK,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,MAAM,EAAE,CAAA;CAAE,CAyDtC"}

package/dist/scripts/sitemap-flat-generator.js

@@ -0,0 +1,231 @@
+/**
+ * Générateur de sitemap PLAT (pas d'imbrication d'index)
+ *
+ * PRINCIPE:
+ * - /sitemap.xml = unique index racine
+ * - /sitemap/{module}/{lang}/{type}.xml = sitemaps de contenu (urlset)
+ * - PAS d'index intermédiaire /sitemap/{module}/sitemap.xml
+ *
+ * Conforme aux recommandations Google Search Console :
+ * "Un sitemap index ne doit pas référencer un autre sitemap index"
+ */
+import fs from "node:fs";
+import path from "node:path";
+/**
+ * Charge le fichier menu-ignored.ts de l'app si disponible
+ */
+function loadMenuIgnored(appDirectory) {
+    try {
+        const menuIgnoredPath = path.join(appDirectory, "..", "config", "menu-ignored.ts");
+        if (!fs.existsSync(menuIgnoredPath)) {
+            return [];
+        }
+        const content = fs.readFileSync(menuIgnoredPath, "utf-8");
+        const ignoredPaths = [];
+        // Parser simple pour extraire les paths du fichier
+        const pathMatches = content.matchAll(/path:\s*["']([^"']+)["']/g);
+        for (const match of pathMatches) {
+            ignoredPaths.push(match[1]);
+        }
+        return ignoredPaths;
+    }
+    catch (error) {
+        return [];
+    }
+}
+/**
+ * Vérifie si un sitemap correspond à une URL ignorée
+ */
+function isSitemapIgnored(sitemapPath, ignoredPaths) {
+    // Extraire le chemin de base du sitemap (sans /sitemap/{module}/{lang}/)
+    // Ex: /sitemap/recipes-pro/fr/static.xml contient les pages comme /fr/...
+    for (const ignoredPath of ignoredPaths) {
+        // Si le sitemap contient une page ignorée, on l'exclut
+        // Note: cette logique peut être affinée selon vos besoins
+        if (sitemapPath.includes("static.xml")) {
+            // Les sitemaps statiques peuvent contenir des pages ignorées
+            // On garde tous les sitemaps statiques pour l'instant
+            // car ils peuvent contenir d'autres pages non ignorées
+            continue;
+        }
+    }
+    return false;
+}
+/**
+ * Collecte tous les sitemaps enfants (urlset) de tous les modules
+ * Sans créer d'index intermédiaires
+ */
+export function collectAllContentSitemaps(moduleManifests, languages, appDirectory) {
+    const entries = [];
+    for (const { manifest } of moduleManifests) {
+        if (!manifest.enabled)
+            continue;
+        // Exclure le module auth (routes bloquées pour l'exploration)
+        if (manifest.module === "auth")
+            continue;
+        for (const child of manifest.children || []) {
+            if (child.kind === "static") {
+                // Générer une entrée par langue
+                for (const lang of languages) {
+                    const childPath = child.path.replace(":lang", lang);
+                    const fullPath = childPath.startsWith("/")
+                        ? childPath
+                        : `/${childPath}`;
+                    // Ajouter le préfixe du module pour éviter les conflits
+                    const modulePath = `/sitemap/${manifest.module}${fullPath}`;
+                    entries.push({
+                        path: modulePath,
+                        module: manifest.module,
+                        kind: child.kind,
+                    });
+                }
+            }
+            else if (child.kind === "reexport") {
+                // Sitemap dynamique - gérer les patterns :lang et :type
+                // Vérifier si le path contient d'autres paramètres que :lang
+                // (comme :type, :id, etc.) - ces sitemaps ne doivent PAS être dans l'index
+                if (child.path.includes(":") &&
+                    child.path.replace(":lang", "").includes(":")) {
+                    // Skip les sitemaps avec des paramètres autres que :lang
+                    // Exemple: :lang/:type/categories.xml contient :type qui n'est pas géré ici
+                    continue;
+                }
+                if (child.path.includes(":lang")) {
+                    // Générer pour chaque langue
+                    for (const lang of languages) {
+                        const childPath = child.path.replace(":lang", lang);
+                        const fullPath = childPath.startsWith("/")
+                            ? childPath
+                            : `/${childPath}`;
+                        // Ajouter le préfixe du module
+                        const modulePath = `/sitemap/${manifest.module}${fullPath}`;
+                        entries.push({
+                            path: modulePath,
+                            module: manifest.module,
+                            kind: child.kind,
+                        });
+                    }
+                }
+                else {
+                    // Pas de paramètre langue - path statique
+                    const fullPath = child.path.startsWith("/")
+                        ? child.path
+                        : `/${child.path}`;
+                    // Ajouter le préfixe du module
+                    const modulePath = `/sitemap/${manifest.module}${fullPath}`;
+                    entries.push({
+                        path: modulePath,
+                        module: manifest.module,
+                        kind: child.kind,
+                    });
+                }
+            }
+        }
+    }
+    // Filtrer les sitemaps selon menu-ignored.ts si appDirectory est fourni
+    if (appDirectory) {
+        const ignoredPaths = loadMenuIgnored(appDirectory);
+        if (ignoredPaths.length > 0) {
+            // Pour l'instant, on ne filtre pas au niveau du sitemap index
+            // car les sitemaps peuvent contenir un mix de pages ignorées et non ignorées
+            // Le filtrage devrait idéalement se faire au niveau des handlers de sitemap individuels
+        }
+    }
+    return entries;
+}
+/**
+ * Génère le sitemap.xml racine PLAT qui liste directement tous les sitemaps de contenu
+ * SANS passer par des index intermédiaires
+ */
+export function generateFlatGlobalSitemapIndex(appDirectory, entries, isDebugMode) {
+    const globalSitemapDir = path.join(appDirectory, "sitemap.xml");
+    const globalSitemapFile = path.join(globalSitemapDir, "route.ts");
+    if (!fs.existsSync(globalSitemapDir)) {
+        fs.mkdirSync(globalSitemapDir, { recursive: true });
+    }
+    // Générer les entrées XML
+    const sitemapEntries = entries
+        .map((entry) => `  <sitemap>
+    <loc>\${baseUrl}${entry.path}</loc>
+    <lastmod>\${new Date().toISOString()}</lastmod>
+  </sitemap>`)
+        .join("\n");
+    const content = `// GENERATED BY LASTBRAIN MODULE BUILD - FLAT Global Sitemap Index
+// Lists ALL content sitemaps directly (NO nested indexes)
+// Total: ${entries.length} sitemap(s)
+// Modules: ${Array.from(new Set(entries.map((e) => e.module))).join(", ")}
+
+export async function GET(): Promise<Response> {
+  const baseUrl =
+    process.env.NEXT_PUBLIC_SITE_URL ||
+    (process.env.VERCEL_URL
+      ? \`https://\${process.env.VERCEL_URL}\`
+      : "https://example.com");
+
+  const xml = \`<?xml version="1.0" encoding="UTF-8"?>
+<sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+${sitemapEntries}
+</sitemapindex>\`;
+
+  return new Response(xml, {
+    headers: {
+      "Content-Type": "application/xml",
+      "Cache-Control": "public, max-age=3600, s-maxage=3600",
+    },
+  });
+}
+`;
+    fs.writeFileSync(globalSitemapFile, content);
+    if (isDebugMode) {
+        console.log(`🌍 Generated FLAT global sitemap index with ${entries.length} content sitemaps`);
+        console.log(`   Modules: ${Array.from(new Set(entries.map((e) => e.module))).join(", ")}`);
+    }
+    return globalSitemapFile;
+}
+/**
+ * Valide qu'aucun sitemap de contenu ne contient de référence circulaire ou imbrication
+ */
+export function validateNoNestedIndexes(appDirectory, entries, isDebugMode) {
+    const errors = [];
+    // Vérifier qu'aucune entrée ne pointe vers un sitemap.xml (qui serait un index)
+    for (const entry of entries) {
+        if (entry.path.endsWith("/sitemap.xml")) {
+            errors.push(`❌ NESTED INDEX DETECTED: ${entry.path} (module: ${entry.module})`);
+        }
+        // Vérifier qu'aucune entrée ne pointe vers la racine /sitemap.xml
+        if (entry.path === "/sitemap.xml") {
+            errors.push(`❌ CIRCULAR REFERENCE: ${entry.path} points to root sitemap (module: ${entry.module})`);
+        }
+    }
+    // Vérifier les fichiers générés pour s'assurer qu'ils sont bien des urlset et pas des sitemapindex
+    for (const entry of entries) {
+        const segments = entry.path
+            .replace(/^\//, "")
+            .replace(/\.xml$/, ".xml")
+            .split("/");
+        const routeDir = path.join(appDirectory, ...segments);
+        const routeFile = path.join(routeDir, "route.ts");
+        if (fs.existsSync(routeFile)) {
+            const content = fs.readFileSync(routeFile, "utf-8");
+            // Vérifier si le fichier contient "sitemapindex" (mauvais)
+            if (content.includes("<sitemapindex")) {
+                errors.push(`❌ FILE IS INDEX NOT URLSET: ${entry.path} contains <sitemapindex> (module: ${entry.module})`);
+            }
+            // Vérifier s'il contient bien "urlset" (bon)
+            if (!content.includes("<urlset") && !content.includes("sitemapindex")) {
+                // Peut être un re-export, c'est OK
+                if (isDebugMode) {
+                    console.log(`   ℹ️  ${entry.path} is a re-export (OK)`);
+                }
+            }
+        }
+    }
+    if (errors.length > 0 && isDebugMode) {
+        console.error("\n🚨 SITEMAP VALIDATION ERRORS:");
+        errors.forEach((err) => console.error(err));
+    }
+    return {
+        valid: errors.length === 0,
+        errors,
+    };
+}

package/dist/scripts/sitemap-manifest-generator.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Nouveau système de sitemaps basé sur les manifests
+ * Architecture PLATE (pas d'imbrication) : index global -> sitemaps enfants (urlset)
+ * Conforme Google Search Console : pas d'index imbriqués
+ */
+import type { ModuleBuildConfig } from "../index.js";
+type SitemapChildKind = "static" | "reexport";
+interface SitemapChild {
+    id: string;
+    path: string;
+    kind: SitemapChildKind;
+    handler?: string;
+    paging?: {
+        pageSize: number;
+    };
+}
+interface SitemapManifest {
+    module: string;
+    enabled: boolean;
+    includePublicPagesFromBuildConfig: boolean;
+    children: SitemapChild[];
+}
+/**
+ * Charge le manifest sitemap d'un module (si existe)
+ */
+export declare function loadModuleManifest(moduleConfig: ModuleBuildConfig, projectRequire: NodeRequire, isDebugMode: boolean): Promise<SitemapManifest | null>;
+/**
+ * Génère le sitemap.xml racine PLAT - liste directement tous les sitemaps de contenu
+ * SUPPRIME les index intermédiaires de modules (pas d'imbrication)
+ */
+export declare function generateGlobalSitemapIndex(appDirectory: string, moduleManifests: Array<{
+    config: ModuleBuildConfig;
+    manifest: SitemapManifest;
+}>, languages: string[], isDebugMode: boolean): void;
+/**
+ * SUPPRIMÉE - Les index de modules créent une imbrication non conforme
+ * Les sitemaps de contenu sont maintenant listés directement dans /sitemap.xml
+ *
+ * Ancienne fonction : generateModuleSitemapIndex()
+ * Raison suppression : Google Search Console refuse les index imbriqués
+ */
+/**
+ * Génère un sitemap enfant statique (pages build.config)
+ */
+export declare function generateStaticSitemap(appDirectory: string, moduleConfig: ModuleBuildConfig, manifest: SitemapManifest, child: any, lang: string, isDebugMode: boolean): void;
+/**
+ * Génère un sitemap enfant dynamique (reexport handler)
+ */
+export declare function generateReexportSitemap(appDirectory: string, manifest: SitemapManifest, child: any, lang: string, type?: string, isDebugMode?: boolean): void;
+/**
+ * Génère tous les sitemaps pour un module
+ */
+export declare function generateModuleSitemaps(appDirectory: string, moduleConfig: ModuleBuildConfig, manifest: SitemapManifest, languages: string[], isDebugMode: boolean): Promise<void>;
+/**
+ * Point d'entrée principal du nouveau système de sitemaps
+ */
+export declare function generateManifestBasedSitemaps(appDirectory: string, moduleConfigs: ModuleBuildConfig[], languages: string[], projectRequire: NodeRequire, isDebugMode: boolean): Promise<void>;
+export {};
+//# sourceMappingURL=sitemap-manifest-generator.d.ts.map

package/dist/scripts/sitemap-manifest-generator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sitemap-manifest-generator.d.ts","sourceRoot":"","sources":["../../src/scripts/sitemap-manifest-generator.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAsCrD,KAAK,gBAAgB,GAAG,QAAQ,GAAG,UAAU,CAAC;AAE9C,UAAU,YAAY;IACpB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,gBAAgB,CAAC;IACvB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE;QACP,QAAQ,EAAE,MAAM,CAAC;KAClB,CAAC;CACH;AAED,UAAU,eAAe;IACvB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,OAAO,CAAC;IACjB,iCAAiC,EAAE,OAAO,CAAC;IAC3C,QAAQ,EAAE,YAAY,EAAE,CAAC;CAC1B;AAED;;GAEG;AACH,wBAAsB,kBAAkB,CACtC,YAAY,EAAE,iBAAiB,EAC/B,cAAc,EAAE,WAAW,EAC3B,WAAW,EAAE,OAAO,GACnB,OAAO,CAAC,eAAe,GAAG,IAAI,CAAC,CA0BjC;AAED;;;GAGG;AACH,wBAAgB,0BAA0B,CACxC,YAAY,EAAE,MAAM,EACpB,eAAe,EAAE,KAAK,CAAC;IACrB,MAAM,EAAE,iBAAiB,CAAC;IAC1B,QAAQ,EAAE,eAAe,CAAC;CAC3B,CAAC,EACF,SAAS,EAAE,MAAM,EAAE,EACnB,WAAW,EAAE,OAAO,QAwCrB;AAED;;;;;;GAMG;AAGH;;GAEG;AACH,wBAAgB,qBAAqB,CACnC,YAAY,EAAE,MAAM,EACpB,YAAY,EAAE,iBAAiB,EAC/B,QAAQ,EAAE,eAAe,EACzB,KAAK,EAAE,GAAG,EACV,IAAI,EAAE,MAAM,EACZ,WAAW,EAAE,OAAO,QAmFrB;AAED;;GAEG;AACH,wBAAgB,uBAAuB,CACrC,YAAY,EAAE,MAAM,EACpB,QAAQ,EAAE,eAAe,EACzB,KAAK,EAAE,GAAG,EACV,IAAI,EAAE,MAAM,EACZ,IAAI,CAAC,EAAE,MAAM,EACb,WAAW,CAAC,EAAE,OAAO,QAgDtB;AAED;;GAEG;AACH,wBAAsB,sBAAsB,CAC1C,YAAY,EAAE,MAAM,EACpB,YAAY,EAAE,iBAAiB,EAC/B,QAAQ,EAAE,eAAe,EACzB,SAAS,EAAE,MAAM,EAAE,EACnB,WAAW,EAAE,OAAO,iBA6ErB;AAED;;GAEG;AACH,wBAAsB,6BAA6B,CACjD,YAAY,EAAE,MAAM,EACpB,aAAa,EAAE,iBAAiB,EAAE,EAClC,SAAS,EAAE,MAAM,EAAE,EACnB,cAAc,EAAE,WAAW,EAC3B,WAAW,EAAE,OAAO,iBAiErB"}