<?xml version="1.0" encoding="UTF-8"?>
<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
  <url>
    <loc>https://tudominio.com/</loc>
    <lastmod>2025-09-29</lastmod>
    <changefreq>weekly</changefreq>
    <priority>1.0</priority>
  </url>
  <url>
    <loc>https://tudominio.com/about</loc>
    <lastmod>2025-09-20</lastmod>
    <changefreq>monthly</changefreq>
    <priority>0.8</priority>
  </url>
</urlset>

app/
├── sitemap.ts      <- Defines tu sitemap aquí
├── page.tsx
└── about/
    └── page.tsx

url: 'https://tudominio.com/blog/mi-post'

lastModified: new Date('2025-09-29')
// O dinámico:
lastModified: new Date()

changeFrequency: 'weekly'

priority: 0.8

// app/sitemap.ts
import type { MetadataRoute } from 'next'
 
// Función para obtener todos tus posts
async function getAllPosts() {
  // Esto depende de donde guardes tus posts
  // Puede ser una base de datos, CMS, o archivos
  const posts = [
    { slug: 'mi-primer-post', date: '2025-09-20' },
    { slug: 'segundo-post', date: '2025-09-25' },
    { slug: 'tercer-post', date: '2025-09-29' },
  ]
  return posts
}
 
export default async function sitemap(): Promise<MetadataRoute.Sitemap> {
  const baseUrl = 'https://tudominio.com'
 
  // páginas estáticas
  const staticPages = [
    {
      url: baseUrl,
      lastModified: new Date(),
      changeFrequency: 'yearly' as const,
      priority: 1,
    },
    {
      url: `${baseUrl}/about`,
      lastModified: new Date(),
      changeFrequency: 'monthly' as const,
      priority: 0.8,
    },
    {
      url: `${baseUrl}/blog`,
      lastModified: new Date(),
      changeFrequency: 'weekly' as const,
      priority: 0.9,
    },
  ]
 
  // páginas dinámicas (posts de blog)
  const posts = await getAllPosts()
  const postPages = posts.map((post) => ({
    url: `${baseUrl}/blog/${post.slug}`,
    lastModified: new Date(post.date),
    changeFrequency: 'monthly' as const,
    priority: 0.6,
  }))
 
  // Combinar todas las páginas
  return [...staticPages, ...postPages]
}

// app/sitemap.ts
import type { MetadataRoute } from 'next'
import fs from 'fs'
import path from 'path'
 
export default async function sitemap(): Promise<MetadataRoute.Sitemap> {
  const baseUrl = 'https://tudominio.com'
  const currentDate = new Date()
 
  // páginas estáticas principales
  const staticPages: MetadataRoute.Sitemap = [
    {
      url: baseUrl,
      lastModified: currentDate,
      changeFrequency: 'weekly',
      priority: 1,
    },
    {
      url: `${baseUrl}/sobre-mi`,
      lastModified: currentDate,
      changeFrequency: 'monthly',
      priority: 0.8,
    },
    {
      url: `${baseUrl}/blog`,
      lastModified: currentDate,
      changeFrequency: 'weekly',
      priority: 0.9,
    },
    {
      url: `${baseUrl}/docs`,
      lastModified: currentDate,
      changeFrequency: 'weekly',
      priority: 0.9,
    },
  ]
 
  // Generar páginas de blog automáticamente
  const blogPages = await generateBlogPages(baseUrl)
 
  // Generar páginas de docs automáticamente
  const docsPages = await generateDocsPages(baseUrl)
 
  return [...staticPages, ...blogPages, ...docsPages]
}
 
// Función para generar páginas de blog automáticamente
async function generateBlogPages(baseUrl: string): Promise<MetadataRoute.Sitemap> {
  const blogDir = path.join(process.cwd(), 'app', 'blog')
 
  try {
    const entries = fs.readdirSync(blogDir, { withFileTypes: true })
 
    return entries
      .filter((entry) => entry.isDirectory() && entry.name !== '[slug]')
      .map((entry) => {
        const slug = entry.name
        const dirPath = path.join(blogDir, slug)
        const stats = fs.statSync(dirPath)
 
        return {
          url: `${baseUrl}/blog/${slug}`,
          lastModified: stats.mtime, // Fecha real de modificación
          changeFrequency: 'monthly' as const,
          priority: 0.7,
        }
      })
  } catch (error) {
    console.error('Error generando páginas de blog:', error)
    return []
  }
}
 
// Función para generar páginas de docs automáticamente
async function generateDocsPages(baseUrl: string): Promise<MetadataRoute.Sitemap> {
  const docsDir = path.join(process.cwd(), 'app', 'docs')
  const pages: MetadataRoute.Sitemap = []
 
  function scanDirectory(dir: string, basePath: string = '/docs') {
    try {
      const entries = fs.readdirSync(dir, { withFileTypes: true })
 
      for (const entry of entries) {
        const fullPath = path.join(dir, entry.name)
 
        if (entry.isDirectory()) {
          const urlPath = `${basePath}/${entry.name}`
          const stats = fs.statSync(fullPath)
 
          pages.push({
            url: `${baseUrl}${urlPath}`,
            lastModified: stats.mtime,
            changeFrequency: 'weekly',
            priority: basePath === '/docs' ? 0.9 : 0.7,
          })
 
          // Escanear recursivamente subcarpetas
          scanDirectory(fullPath, urlPath)
        }
      }
    } catch (error) {
      console.error('Error escaneando directorio:', dir, error)
    }
  }
 
  scanDirectory(docsDir)
  return pages
}

export default async function sitemap(): Promise<MetadataRoute.Sitemap> {
  const baseUrl = 'https://tudominio.com'
 
  // páginas principales (manual para control fino)
  const staticPages = [/* ... */]
 
  // Blog automático (filesystem)
  const blogPages = await generateBlogPages(baseUrl)
 
  // Productos desde base de datos (manual)
  const products = await db.product.findMany()
  const productPages = products.map((product) => ({
    url: `${baseUrl}/productos/${product.slug}`,
    lastModified: product.updatedAt,
    changeFrequency: 'weekly' as const,
    priority: 0.8,
  }))
 
  return [...staticPages, ...blogPages, ...productPages]
}

// app/sitemap.ts
import type { MetadataRoute } from 'next'
 
export default async function sitemap(): Promise<MetadataRoute.Sitemap> {
  const baseUrl = 'https://rodalexanderson.com'
  const currentDate = new Date()
 
  // páginas principales
  const mainPages = [
    {
      url: baseUrl,
      lastModified: currentDate,
      changeFrequency: 'weekly' as const,
      priority: 1,
    },
    {
      url: `${baseUrl}/sobre-mi`,
      lastModified: currentDate,
      changeFrequency: 'monthly' as const,
      priority: 0.8,
    },
    {
      url: `${baseUrl}/blog`,
      lastModified: currentDate,
      changeFrequency: 'weekly' as const,
      priority: 0.9,
    },
    {
      url: `${baseUrl}/docs`,
      lastModified: currentDate,
      changeFrequency: 'weekly' as const,
      priority: 0.9,
    },
  ]
 
  // Documentación de NextJS
  const docsPages = [
    'v16',
    'v16/instalacion',
    'v16/routing',
    'v16/rendering',
    'v16/rendering/client-components',
    'v16/data-fetching',
  ].map((path) => ({
    url: `${baseUrl}/docs/nextjs/${path}`,
    lastModified: currentDate,
    changeFrequency: 'monthly' as const,
    priority: 0.7,
  }))
 
  return [...mainPages, ...docsPages]
}

// app/sitemap.ts
import type { MetadataRoute } from 'next'
import { db } from '@/lib/database'
 
export default async function sitemap(): Promise<MetadataRoute.Sitemap> {
  const baseUrl = 'https://tudominio.com'
 
  // Obtener posts de la base de datos
  const posts = await db.post.findMany({
    where: { published: true },
    select: {
      slug: true,
      updatedAt: true,
    },
  })
 
  // Convertir a formato de sitemap
  const postPages = posts.map((post) => ({
    url: `${baseUrl}/blog/${post.slug}`,
    lastModified: post.updatedAt,
    changeFrequency: 'monthly' as const,
    priority: 0.7,
  }))
 
  // páginas estáticas
  const staticPages = [
    {
      url: baseUrl,
      lastModified: new Date(),
      changeFrequency: 'weekly' as const,
      priority: 1,
    },
  ]
 
  return [...staticPages, ...postPages]
}

// Correcto
url: 'https://tudominio.com/blog/post'
 
// Incorrecto
url: '/blog/post'

// Bueno - Fecha real del post
lastModified: post.updatedAt
 
// Malo - Siempre la fecha actual
lastModified: new Date()

// app/sitemap.ts
const baseUrl = process.env.NEXT_PUBLIC_SITE_URL || 'https://tudominio.com'

NEXT_PUBLIC_SITE_URL=http://localhost:3000

NEXT_PUBLIC_SITE_URL=https://tudominio.com