@onruntime/next-sitemap 0.2.1 → 0.4.0

package/README.md

@@ -5,11 +5,15 @@ Dynamic sitemap generation for Next.js with automatic route discovery.
 ## Example
 
 - [Next.js App Router](https://github.com/onRuntime/onruntime/tree/master/examples/next-sitemap/app)
+- [Next.js App Router with i18n](https://github.com/onRuntime/onruntime/tree/master/examples/next-sitemap/app-with-locales)
+- [Next.js Pages Router](https://github.com/onRuntime/onruntime/tree/master/examples/next-sitemap/pages)
+- [Next.js Pages Router with i18n](https://github.com/onRuntime/onruntime/tree/master/examples/next-sitemap/pages-with-locales)
 
 ## Features
 
+- **App Router** and **Pages Router** support
 - Automatic route discovery using `require.context`
-- Calls `generateStaticParams` for dynamic routes
+- Calls `generateStaticParams` (App Router) or `getStaticPaths` (Pages Router) for dynamic routes
 - Multi-sitemap support with sitemap index (for sites with >50,000 URLs)
 - hreflang alternates for i18n
 - Fully static generation (SSG)
@@ -104,6 +108,89 @@ const nextConfig: NextConfig = {
 export default nextConfig;
 ```
 
+### Next.js Pages Router
+
+#### 1. Create the sitemap index API route
+
+```typescript
+// pages/api/sitemap.xml.ts
+import { createSitemapIndexApiHandler } from "@onruntime/next-sitemap/pages";
+
+// @ts-expect-error - require.context is a webpack/turbopack feature
+const pagesContext = require.context("../", true, /^\.\/(?!\[|_|api\/).*\.tsx$/);
+
+export default createSitemapIndexApiHandler({
+  baseUrl: "https://example.com",
+  pagesContext,
+});
+```
+
+#### 2. Create the individual sitemap API route
+
+```typescript
+// pages/api/sitemap/[id].ts
+import { createSitemapApiHandler } from "@onruntime/next-sitemap/pages";
+
+// @ts-expect-error - require.context is a webpack/turbopack feature
+const pagesContext = require.context("../../", true, /^\.\/(?!\[|_|api\/).*\.tsx$/);
+
+export default createSitemapApiHandler({
+  baseUrl: "https://example.com",
+  pagesContext,
+});
+```
+
+#### 3. Add URL rewrite in next.config.ts
+
+```typescript
+// next.config.ts
+import type { NextConfig } from "next";
+
+const nextConfig: NextConfig = {
+  async rewrites() {
+    return [
+      {
+        source: "/sitemap.xml",
+        destination: "/api/sitemap.xml",
+      },
+      {
+        source: "/sitemap-:id.xml",
+        destination: "/api/sitemap/:id",
+      },
+    ];
+  },
+};
+
+export default nextConfig;
+```
+
+#### With i18n (optional)
+
+The Pages Router uses Next.js native i18n config in `next.config.js`. Pages stay in `pages/` (no `[locale]` folder), and you just need to provide `locales` and `defaultLocale`:
+
+```typescript
+// next.config.js
+module.exports = {
+  i18n: {
+    locales: ['en', 'fr'],
+    defaultLocale: 'en',
+  },
+}
+
+// pages/api/sitemap.xml.ts
+import { createSitemapIndexApiHandler } from "@onruntime/next-sitemap/pages";
+
+// @ts-expect-error - require.context is a webpack/turbopack feature
+const pagesContext = require.context("../", true, /^\.\/(?!\[|_|api\/).*\.tsx$/);
+
+export default createSitemapIndexApiHandler({
+  baseUrl: "https://example.com",
+  locales: ["en", "fr"],
+  defaultLocale: "en",
+  pagesContext,
+});
+```
+
 ### Configuration Options
 
 | Option | Type | Default | Description |
@@ -118,6 +205,7 @@ export default nextConfig;
 | `priority` | `number`, `"auto"`, or `function` | `"auto"` | Priority calculation (auto = depth-based) |
 | `changeFreq` | `ChangeFrequency` or `function` | `"weekly"` | Change frequency for entries |
 | `additionalSitemaps` | `string[]` | `[]` | Additional sitemaps to include in index |
+| `debug` | `boolean` | `false` | Enable debug logging to diagnose route discovery issues |
 
 #### Exclude Routes
 
@@ -191,9 +279,9 @@ const { GET } = createSitemapIndexHandler({
 
 ### How It Works
 
-1. `require.context` scans your app directory at build time
+1. `require.context` scans your app/pages directory at build time
 2. For each page found, it extracts the route path
-3. For dynamic routes (e.g., `/projects/[id]`), it calls `generateStaticParams`
+3. For dynamic routes (e.g., `/projects/[id]`), it calls `generateStaticParams` (App Router) or `getStaticPaths` (Pages Router)
 4. URLs are paginated into multiple sitemaps (default: 5000 URLs each)
 5. A sitemap index lists all individual sitemaps
 
@@ -266,6 +354,81 @@ export async function GET() {
 </urlset>
 ```
 
+## Troubleshooting
+
+### Dynamic routes not included in sitemap
+
+If your dynamic routes (e.g., `/articles/[slug]`) are not appearing in the sitemap, enable debug mode to diagnose:
+
+```typescript
+const { GET } = createSitemapIndexHandler({
+  baseUrl: "https://example.com",
+  pagesContext,
+  debug: true, // Enable debug logging
+});
+```
+
+This will log:
+- All discovered routes and whether `generateStaticParams` was found
+- Number of params returned by each `generateStaticParams` call
+- Any errors that occur during param generation
+
+**Common issues:**
+
+1. **`generateStaticParams`/`getStaticPaths` not detected**: Make sure it's exported at the top level of your page file:
+   ```typescript
+   // ✅ Correct (App Router)
+   export async function generateStaticParams() { ... }
+
+   // ✅ Correct (Pages Router)
+   export async function getStaticPaths() { ... }
+
+   // ❌ Wrong - not exported
+   async function generateStaticParams() { ... }
+   ```
+
+2. **Database/API errors**: If `generateStaticParams` fetches data from a database or API, errors are caught and logged. Check the console for error messages.
+
+3. **Empty params returned**: If `generateStaticParams` returns an empty array, no dynamic paths will be generated.
+
+### Recommended approach for API/Database routes
+
+For routes that fetch data from external sources (APIs, databases like Payload CMS), we recommend using `additionalSitemaps` with a custom sitemap route:
+
+```typescript
+// app/sitemap.xml/route.ts
+const { GET } = createSitemapIndexHandler({
+  baseUrl: "https://example.com",
+  pagesContext,
+  additionalSitemaps: ["/articles-sitemap.xml"],
+});
+
+// app/articles-sitemap.xml/route.ts
+import { generateSitemapXml } from "@onruntime/next-sitemap";
+import { getPayload } from "payload";
+
+export async function GET() {
+  const payload = await getPayload({ config: configPromise });
+  const articles = await payload.find({
+    collection: "articles",
+    limit: 1000,
+    select: { slug: true, updatedAt: true },
+  });
+
+  const entries = articles.docs.map((article) => ({
+    url: `https://example.com/articles/${article.slug}`,
+    lastModified: article.updatedAt,
+    priority: 0.7,
+  }));
+
+  return new Response(generateSitemapXml(entries), {
+    headers: { "Content-Type": "application/xml" },
+  });
+}
+```
+
+This approach gives you full control over data fetching and error handling.
+
 ## License
 
 MIT

package/dist/app/index.cjs

@@ -123,7 +123,7 @@ function extractRoutes(pagesContext, localeSegment) {
   }
   return routes;
 }
-async function getAllPaths(routes) {
+async function getAllPaths(routes, debug = false) {
   const allPaths = ["/"];
   const seenPaths = /* @__PURE__ */ new Set(["/"]);
   for (const route of routes) {
@@ -133,16 +133,36 @@ async function getAllPaths(routes) {
         seenPaths.add(route.pathname);
       }
     } else if (route.getParams) {
-      const params = await route.getParams();
-      for (const param of params) {
-        let dynamicPath = route.pathname;
-        for (const segment of route.dynamicSegments) {
-          dynamicPath = dynamicPath.replace(`[${segment}]`, param[segment]);
+      try {
+        const params = await route.getParams();
+        if (debug) {
+          console.log(`[next-sitemap] ${route.pathname}: generateStaticParams returned ${params.length} params`);
         }
-        if (!seenPaths.has(dynamicPath)) {
-          allPaths.push(dynamicPath);
-          seenPaths.add(dynamicPath);
+        for (const param of params) {
+          let dynamicPath = route.pathname;
+          for (const segment of route.dynamicSegments) {
+            const value = param[segment];
+            if (value === void 0) {
+              if (debug) {
+                console.warn(`[next-sitemap] ${route.pathname}: missing param "${segment}" in`, param);
+              }
+              continue;
+            }
+            dynamicPath = dynamicPath.replace(`[${segment}]`, value);
+          }
+          if (!seenPaths.has(dynamicPath)) {
+            allPaths.push(dynamicPath);
+            seenPaths.add(dynamicPath);
+          }
         }
+      } catch (error) {
+        console.error(`[next-sitemap] Error calling generateStaticParams for ${route.pathname}:`, error);
+      }
+    } else if (route.dynamicSegments.length > 0) {
+      if (debug) {
+        console.warn(
+          `[next-sitemap] Skipping dynamic route ${route.pathname}: no generateStaticParams exported. Use additionalSitemaps for routes that fetch data at runtime.`
+        );
       }
     }
   }
@@ -172,12 +192,20 @@ function pathsToEntries(paths, config) {
   });
 }
 function createSitemapIndexHandler(options) {
-  const { urlsPerSitemap = 5e3, locales = [], defaultLocale, additionalSitemaps, exclude } = options;
+  const { urlsPerSitemap = 5e3, locales = [], defaultLocale, additionalSitemaps, exclude, debug = false } = options;
   const localeSegment = options.localeSegment ?? (locales.length > 0 || defaultLocale ? "[locale]" : "");
   const routes = extractRoutes(options.pagesContext, localeSegment);
+  if (debug) {
+    console.log(`[next-sitemap] Found ${routes.length} routes:`);
+    routes.forEach((r) => {
+      const hasParams = r.getParams ? "\u2713 generateStaticParams" : "\u2717 no generateStaticParams";
+      const segments = r.dynamicSegments.length > 0 ? ` [${r.dynamicSegments.join(", ")}]` : "";
+      console.log(`  ${r.pathname}${segments} - ${hasParams}`);
+    });
+  }
   return {
     GET: async () => {
-      const allPaths = await getAllPaths(routes);
+      const allPaths = await getAllPaths(routes, debug);
       const filteredPaths = allPaths.filter((pathname) => !shouldExclude(pathname, exclude));
       const sitemapCount = Math.max(1, Math.ceil(filteredPaths.length / urlsPerSitemap));
       const xml = generateSitemapIndexXml(options.baseUrl, sitemapCount, {
@@ -190,11 +218,11 @@ function createSitemapIndexHandler(options) {
   };
 }
 function createSitemapHandler(options) {
-  const { urlsPerSitemap = 5e3, locales = [], defaultLocale, exclude } = options;
+  const { urlsPerSitemap = 5e3, locales = [], defaultLocale, exclude, debug = false } = options;
   const localeSegment = options.localeSegment ?? (locales.length > 0 || defaultLocale ? "[locale]" : "");
   const routes = extractRoutes(options.pagesContext, localeSegment);
   const getFilteredPaths = async () => {
-    const allPaths = await getAllPaths(routes);
+    const allPaths = await getAllPaths(routes, debug);
     return allPaths.filter((pathname) => !shouldExclude(pathname, exclude));
   };
   return {

package/dist/app/index.d.cts

@@ -79,6 +79,12 @@ interface CreateSitemapHandlerOptions extends SitemapConfig {
         keys: () => string[];
         (key: string): PageModule;
     };
+    /**
+     * Enable debug logging to diagnose issues with route discovery
+     * Logs info about generateStaticParams calls and skipped routes
+     * @default false
+     */
+    debug?: boolean;
 }
 /**
  * Create handlers for sitemap index route

package/dist/app/index.d.ts

@@ -79,6 +79,12 @@ interface CreateSitemapHandlerOptions extends SitemapConfig {
         keys: () => string[];
         (key: string): PageModule;
     };
+    /**
+     * Enable debug logging to diagnose issues with route discovery
+     * Logs info about generateStaticParams calls and skipped routes
+     * @default false
+     */
+    debug?: boolean;
 }
 /**
  * Create handlers for sitemap index route

package/dist/app/index.js

@@ -121,7 +121,7 @@ function extractRoutes(pagesContext, localeSegment) {
   }
   return routes;
 }
-async function getAllPaths(routes) {
+async function getAllPaths(routes, debug = false) {
   const allPaths = ["/"];
   const seenPaths = /* @__PURE__ */ new Set(["/"]);
   for (const route of routes) {
@@ -131,16 +131,36 @@ async function getAllPaths(routes) {
         seenPaths.add(route.pathname);
       }
     } else if (route.getParams) {
-      const params = await route.getParams();
-      for (const param of params) {
-        let dynamicPath = route.pathname;
-        for (const segment of route.dynamicSegments) {
-          dynamicPath = dynamicPath.replace(`[${segment}]`, param[segment]);
+      try {
+        const params = await route.getParams();
+        if (debug) {
+          console.log(`[next-sitemap] ${route.pathname}: generateStaticParams returned ${params.length} params`);
         }
-        if (!seenPaths.has(dynamicPath)) {
-          allPaths.push(dynamicPath);
-          seenPaths.add(dynamicPath);
+        for (const param of params) {
+          let dynamicPath = route.pathname;
+          for (const segment of route.dynamicSegments) {
+            const value = param[segment];
+            if (value === void 0) {
+              if (debug) {
+                console.warn(`[next-sitemap] ${route.pathname}: missing param "${segment}" in`, param);
+              }
+              continue;
+            }
+            dynamicPath = dynamicPath.replace(`[${segment}]`, value);
+          }
+          if (!seenPaths.has(dynamicPath)) {
+            allPaths.push(dynamicPath);
+            seenPaths.add(dynamicPath);
+          }
         }
+      } catch (error) {
+        console.error(`[next-sitemap] Error calling generateStaticParams for ${route.pathname}:`, error);
+      }
+    } else if (route.dynamicSegments.length > 0) {
+      if (debug) {
+        console.warn(
+          `[next-sitemap] Skipping dynamic route ${route.pathname}: no generateStaticParams exported. Use additionalSitemaps for routes that fetch data at runtime.`
+        );
       }
     }
   }
@@ -170,12 +190,20 @@ function pathsToEntries(paths, config) {
   });
 }
 function createSitemapIndexHandler(options) {
-  const { urlsPerSitemap = 5e3, locales = [], defaultLocale, additionalSitemaps, exclude } = options;
+  const { urlsPerSitemap = 5e3, locales = [], defaultLocale, additionalSitemaps, exclude, debug = false } = options;
   const localeSegment = options.localeSegment ?? (locales.length > 0 || defaultLocale ? "[locale]" : "");
   const routes = extractRoutes(options.pagesContext, localeSegment);
+  if (debug) {
+    console.log(`[next-sitemap] Found ${routes.length} routes:`);
+    routes.forEach((r) => {
+      const hasParams = r.getParams ? "\u2713 generateStaticParams" : "\u2717 no generateStaticParams";
+      const segments = r.dynamicSegments.length > 0 ? ` [${r.dynamicSegments.join(", ")}]` : "";
+      console.log(`  ${r.pathname}${segments} - ${hasParams}`);
+    });
+  }
   return {
     GET: async () => {
-      const allPaths = await getAllPaths(routes);
+      const allPaths = await getAllPaths(routes, debug);
       const filteredPaths = allPaths.filter((pathname) => !shouldExclude(pathname, exclude));
       const sitemapCount = Math.max(1, Math.ceil(filteredPaths.length / urlsPerSitemap));
       const xml = generateSitemapIndexXml(options.baseUrl, sitemapCount, {
@@ -188,11 +216,11 @@ function createSitemapIndexHandler(options) {
   };
 }
 function createSitemapHandler(options) {
-  const { urlsPerSitemap = 5e3, locales = [], defaultLocale, exclude } = options;
+  const { urlsPerSitemap = 5e3, locales = [], defaultLocale, exclude, debug = false } = options;
   const localeSegment = options.localeSegment ?? (locales.length > 0 || defaultLocale ? "[locale]" : "");
   const routes = extractRoutes(options.pagesContext, localeSegment);
   const getFilteredPaths = async () => {
-    const allPaths = await getAllPaths(routes);
+    const allPaths = await getAllPaths(routes, debug);
     return allPaths.filter((pathname) => !shouldExclude(pathname, exclude));
   };
   return {

package/dist/pages/index.cjs

@@ -0,0 +1,267 @@
+'use strict';
+
+// src/index.ts
+function calculateDepthPriority(pathname) {
+  if (pathname === "/") return 1;
+  const depth = pathname.split("/").filter(Boolean).length;
+  return Math.max(0.1, 1 - depth * 0.2);
+}
+function shouldExclude(pathname, exclude) {
+  if (!exclude) return false;
+  if (typeof exclude === "function") {
+    return exclude(pathname);
+  }
+  return exclude.some((pattern) => {
+    const regexPattern = pattern.replace(/\*\*/g, "{{DOUBLE_STAR}}").replace(/\*/g, "[^/]*").replace(/\{\{DOUBLE_STAR\}\}/g, ".*");
+    const regex = new RegExp(`^${regexPattern}$`);
+    return regex.test(pathname);
+  });
+}
+function getPriority(pathname, priority) {
+  if (priority === void 0 || priority === "auto") {
+    return calculateDepthPriority(pathname);
+  }
+  if (typeof priority === "function") {
+    return priority(pathname);
+  }
+  return priority;
+}
+function getChangeFreq(pathname, changeFreq) {
+  if (changeFreq === void 0) {
+    return "weekly";
+  }
+  if (typeof changeFreq === "function") {
+    return changeFreq(pathname);
+  }
+  return changeFreq;
+}
+function buildUrl(baseUrl, pathname, locale, defaultLocale) {
+  if (!locale || locale === defaultLocale) {
+    return `${baseUrl}${pathname}`;
+  }
+  return `${baseUrl}/${locale}${pathname}`;
+}
+function generateSitemapXml(entries) {
+  const hasAlternates = entries.some((e) => e.alternates?.languages);
+  const xmlns = hasAlternates ? 'xmlns="http://www.sitemaps.org/schemas/sitemap/0.9" xmlns:xhtml="http://www.w3.org/1999/xhtml"' : 'xmlns="http://www.sitemaps.org/schemas/sitemap/0.9"';
+  const urlEntries = entries.map((entry) => {
+    const parts = [`    <loc>${entry.url}</loc>`];
+    if (entry.alternates?.languages) {
+      for (const [lang, href] of Object.entries(entry.alternates.languages)) {
+        parts.push(`    <xhtml:link rel="alternate" hreflang="${lang}" href="${href}" />`);
+      }
+    }
+    if (entry.lastModified) {
+      const date = entry.lastModified instanceof Date ? entry.lastModified.toISOString() : entry.lastModified;
+      parts.push(`    <lastmod>${date}</lastmod>`);
+    }
+    if (entry.changeFrequency) {
+      parts.push(`    <changefreq>${entry.changeFrequency}</changefreq>`);
+    }
+    if (entry.priority !== void 0) {
+      parts.push(`    <priority>${entry.priority}</priority>`);
+    }
+    return `  <url>
+${parts.join("\n")}
+  </url>`;
+  }).join("\n");
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<urlset ${xmlns}>
+${urlEntries}
+</urlset>`;
+}
+function generateSitemapIndexXml(baseUrl, sitemapCount, options) {
+  const { sitemapPattern = "/sitemap-{id}.xml", additionalSitemaps = [] } = options || {};
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const paginatedEntries = Array.from({ length: sitemapCount }, (_, i) => {
+    const loc = `${baseUrl}${sitemapPattern.replace("{id}", String(i))}`;
+    return `  <sitemap>
+    <loc>${loc}</loc>
+    <lastmod>${now}</lastmod>
+  </sitemap>`;
+  });
+  const additionalEntries = additionalSitemaps.map((sitemap) => {
+    const loc = sitemap.startsWith("http") ? sitemap : `${baseUrl}${sitemap}`;
+    return `  <sitemap>
+    <loc>${loc}</loc>
+    <lastmod>${now}</lastmod>
+  </sitemap>`;
+  });
+  const allEntries = [...paginatedEntries, ...additionalEntries].join("\n");
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+${allEntries}
+</sitemapindex>`;
+}
+
+// src/pages/index.ts
+function extractRoutes(pagesContext, localeSegment) {
+  const routes = [];
+  for (const key of pagesContext.keys()) {
+    if (key.includes("[...")) continue;
+    if (key.includes("/api/")) continue;
+    if (key.includes("/_")) continue;
+    const pageModule = pagesContext(key);
+    let pathname = key.replace(/^\.\//, "/").replace(/\.tsx?$/, "").replace(/\/index$/, "/");
+    if (pathname === "") pathname = "/";
+    if (localeSegment) {
+      pathname = pathname.replace(
+        new RegExp(`^/${localeSegment.replace(/[[\]]/g, "\\$&")}`),
+        ""
+      );
+    }
+    if (/(?:^|\/)(src|pages)(?:\/|$)/.test(pathname)) continue;
+    if (!pathname || pathname === "") {
+      pathname = "/";
+    } else if (!pathname.startsWith("/")) {
+      pathname = "/" + pathname;
+    }
+    const dynamicSegments = pathname.match(/\[([^\]]+)\]/g)?.map((s) => s.slice(1, -1)) || [];
+    const getStaticPaths = pageModule.getStaticPaths;
+    let getParams = null;
+    if (getStaticPaths) {
+      getParams = async () => {
+        const result = await getStaticPaths();
+        return result.paths.map((p) => p.params);
+      };
+    } else if (pageModule.generateStaticParams) {
+      getParams = pageModule.generateStaticParams;
+    }
+    routes.push({
+      pathname,
+      dynamicSegments,
+      getParams
+    });
+  }
+  return routes;
+}
+async function getAllPaths(routes, debug = false) {
+  const allPaths = ["/"];
+  const seenPaths = /* @__PURE__ */ new Set(["/"]);
+  for (const route of routes) {
+    if (route.dynamicSegments.length === 0) {
+      if (route.pathname !== "/" && !seenPaths.has(route.pathname)) {
+        allPaths.push(route.pathname);
+        seenPaths.add(route.pathname);
+      }
+    } else if (route.getParams) {
+      try {
+        const params = await route.getParams();
+        if (debug) {
+          console.log(`[next-sitemap] ${route.pathname}: getStaticPaths returned ${params.length} params`);
+        }
+        for (const param of params) {
+          let dynamicPath = route.pathname;
+          for (const segment of route.dynamicSegments) {
+            const value = param[segment];
+            if (value === void 0) {
+              if (debug) {
+                console.warn(`[next-sitemap] ${route.pathname}: missing param "${segment}" in`, param);
+              }
+              continue;
+            }
+            dynamicPath = dynamicPath.replace(`[${segment}]`, value);
+          }
+          if (!seenPaths.has(dynamicPath)) {
+            allPaths.push(dynamicPath);
+            seenPaths.add(dynamicPath);
+          }
+        }
+      } catch (error) {
+        console.error(`[next-sitemap] Error calling getStaticPaths for ${route.pathname}:`, error);
+      }
+    } else if (route.dynamicSegments.length > 0) {
+      if (debug) {
+        console.warn(
+          `[next-sitemap] Skipping dynamic route ${route.pathname}: no getStaticPaths exported. Use additionalSitemaps for routes that fetch data at runtime.`
+        );
+      }
+    }
+  }
+  return allPaths;
+}
+function pathsToEntries(paths, config) {
+  const { baseUrl, locales = [], defaultLocale, exclude, priority, changeFreq } = config;
+  const filteredPaths = paths.filter((pathname) => !shouldExclude(pathname, exclude));
+  return filteredPaths.map((pathname) => {
+    const entry = {
+      url: buildUrl(baseUrl, pathname, defaultLocale, defaultLocale),
+      lastModified: /* @__PURE__ */ new Date(),
+      changeFrequency: getChangeFreq(pathname, changeFreq),
+      priority: getPriority(pathname, priority)
+    };
+    if (locales.length > 0) {
+      entry.alternates = {
+        languages: Object.fromEntries(
+          locales.map((locale) => [
+            locale,
+            buildUrl(baseUrl, pathname, locale, defaultLocale)
+          ])
+        )
+      };
+    }
+    return entry;
+  });
+}
+function createSitemapIndexApiHandler(options) {
+  const { urlsPerSitemap = 5e3, additionalSitemaps, exclude, debug = false } = options;
+  const localeSegment = options.localeSegment ?? "";
+  const routes = extractRoutes(options.pagesContext, localeSegment);
+  if (debug) {
+    console.log(`[next-sitemap] Found ${routes.length} routes:`);
+    routes.forEach((r) => {
+      const hasParams = r.getParams ? "\u2713 getStaticPaths" : "\u2717 no getStaticPaths";
+      const segments = r.dynamicSegments.length > 0 ? ` [${r.dynamicSegments.join(", ")}]` : "";
+      console.log(`  ${r.pathname}${segments} - ${hasParams}`);
+    });
+  }
+  return async function handler(_req, res) {
+    const allPaths = await getAllPaths(routes, debug);
+    const filteredPaths = allPaths.filter((pathname) => !shouldExclude(pathname, exclude));
+    const sitemapCount = Math.max(1, Math.ceil(filteredPaths.length / urlsPerSitemap));
+    const xml = generateSitemapIndexXml(options.baseUrl, sitemapCount, {
+      additionalSitemaps
+    });
+    res.setHeader("Content-Type", "application/xml");
+    res.status(200).send(xml);
+  };
+}
+function createSitemapApiHandler(options) {
+  const { urlsPerSitemap = 5e3, exclude, debug = false } = options;
+  const localeSegment = options.localeSegment ?? "";
+  const routes = extractRoutes(options.pagesContext, localeSegment);
+  const getFilteredPaths = async () => {
+    const allPaths = await getAllPaths(routes, debug);
+    return allPaths.filter((pathname) => !shouldExclude(pathname, exclude));
+  };
+  return async function handler(req, res) {
+    const { id } = req.query;
+    const sitemapId = parseInt(Array.isArray(id) ? id[0] : id || "0", 10);
+    const filteredPaths = await getFilteredPaths();
+    const start = sitemapId * urlsPerSitemap;
+    const end = start + urlsPerSitemap;
+    const paths = filteredPaths.slice(start, end);
+    const entries = pathsToEntries(paths, { ...options, exclude: void 0 });
+    const xml = generateSitemapXml(entries);
+    res.setHeader("Content-Type", "application/xml");
+    res.status(200).send(xml);
+  };
+}
+async function getSitemapStaticPaths(options) {
+  const { urlsPerSitemap = 5e3, exclude, debug = false } = options;
+  const localeSegment = options.localeSegment ?? "";
+  const routes = extractRoutes(options.pagesContext, localeSegment);
+  const allPaths = await getAllPaths(routes, debug);
+  const filteredPaths = allPaths.filter((pathname) => !shouldExclude(pathname, exclude));
+  const sitemapCount = Math.max(1, Math.ceil(filteredPaths.length / urlsPerSitemap));
+  return {
+    paths: Array.from({ length: sitemapCount }, (_, i) => ({
+      params: { id: String(i) }
+    })),
+    fallback: false
+  };
+}
+
+exports.createSitemapApiHandler = createSitemapApiHandler;
+exports.createSitemapIndexApiHandler = createSitemapIndexApiHandler;
+exports.getSitemapStaticPaths = getSitemapStaticPaths;

package/dist/pages/index.d.cts

@@ -0,0 +1,114 @@
+import { NextApiRequest, NextApiResponse } from 'next';
+
+type ChangeFrequency = "always" | "hourly" | "daily" | "weekly" | "monthly" | "yearly" | "never";
+interface SitemapConfig {
+    /**
+     * Base URL of the site (e.g., "https://example.com")
+     */
+    baseUrl: string;
+    /**
+     * List of supported locales (e.g., ["en", "fr"])
+     */
+    locales?: string[];
+    /**
+     * Default locale (e.g., "en")
+     */
+    defaultLocale?: string;
+    /**
+     * Number of URLs per sitemap file (default: 5000)
+     */
+    urlsPerSitemap?: number;
+    /**
+     * Path to the app directory relative to the project root
+     * Default: "./src/app" or "./app"
+     */
+    appDir?: string;
+    /**
+     * Locale segment in the URL path (e.g., "[locale]")
+     * Auto-detected as "[locale]" when locales or defaultLocale is set
+     */
+    localeSegment?: string;
+    /**
+     * Exclude routes from the sitemap
+     * Can be an array of glob patterns or a function that returns true to exclude
+     * @example exclude: ["/admin/*", "/api/*"]
+     * @example exclude: (path) => path.startsWith("/private")
+     */
+    exclude?: string[] | ((path: string) => boolean);
+    /**
+     * Priority for sitemap entries
+     * Can be a fixed number (0.0-1.0), a function, or "auto" for depth-based calculation
+     * Default: "auto" (1.0 - depth * 0.2, minimum 0.1)
+     * @example priority: 0.8
+     * @example priority: (path) => path === "/" ? 1.0 : 0.7
+     * @example priority: "auto"
+     */
+    priority?: number | "auto" | ((path: string) => number);
+    /**
+     * Change frequency for sitemap entries
+     * Can be a fixed value or a function
+     * Default: "weekly"
+     * @example changeFreq: "daily"
+     * @example changeFreq: (path) => path === "/" ? "daily" : "weekly"
+     */
+    changeFreq?: ChangeFrequency | ((path: string) => ChangeFrequency);
+    /**
+     * Additional sitemaps to include in the sitemap index
+     * Useful for custom sitemaps (e.g., products from an API)
+     * @example additionalSitemaps: ["/products-sitemap.xml", "/blog-sitemap.xml"]
+     */
+    additionalSitemaps?: string[];
+}
+interface SitemapEntry {
+    url: string;
+    lastModified?: string | Date;
+    changeFrequency?: ChangeFrequency;
+    priority?: number;
+    alternates?: {
+        languages?: Record<string, string>;
+    };
+}
+type PageModule = {
+    generateStaticParams?: () => Promise<Record<string, string>[]>;
+};
+
+interface CreateSitemapApiHandlerOptions extends SitemapConfig {
+    /**
+     * The require.context result for page discovery
+     * Example: require.context('./', true, /^\.\/(?!\[|_|api\/).*\.tsx$/)
+     */
+    pagesContext: {
+        keys: () => string[];
+        (key: string): PageModule;
+    };
+    /**
+     * Enable debug logging to diagnose issues with route discovery
+     * Logs info about getStaticPaths calls and skipped routes
+     * @default false
+     */
+    debug?: boolean;
+}
+/**
+ * Create API handler for sitemap index route
+ * Use in: pages/api/sitemap.xml.ts or pages/sitemap.xml.ts (with rewrites)
+ */
+declare function createSitemapIndexApiHandler(options: CreateSitemapApiHandlerOptions): (_req: NextApiRequest, res: NextApiResponse) => Promise<void>;
+/**
+ * Create API handler for individual sitemap routes
+ * Use in: pages/api/sitemap/[id].ts or pages/sitemap-[id].xml.ts (with rewrites)
+ */
+declare function createSitemapApiHandler(options: CreateSitemapApiHandlerOptions): (req: NextApiRequest, res: NextApiResponse) => Promise<void>;
+/**
+ * Get the list of sitemap IDs for getStaticPaths
+ * Use this to pre-render sitemap pages at build time
+ */
+declare function getSitemapStaticPaths(options: CreateSitemapApiHandlerOptions): Promise<{
+    paths: {
+        params: {
+            id: string;
+        };
+    }[];
+    fallback: boolean;
+}>;
+
+export { type ChangeFrequency, type CreateSitemapApiHandlerOptions, type SitemapConfig, type SitemapEntry, createSitemapApiHandler, createSitemapIndexApiHandler, getSitemapStaticPaths };

package/dist/pages/index.d.ts

@@ -0,0 +1,114 @@
+import { NextApiRequest, NextApiResponse } from 'next';
+
+type ChangeFrequency = "always" | "hourly" | "daily" | "weekly" | "monthly" | "yearly" | "never";
+interface SitemapConfig {
+    /**
+     * Base URL of the site (e.g., "https://example.com")
+     */
+    baseUrl: string;
+    /**
+     * List of supported locales (e.g., ["en", "fr"])
+     */
+    locales?: string[];
+    /**
+     * Default locale (e.g., "en")
+     */
+    defaultLocale?: string;
+    /**
+     * Number of URLs per sitemap file (default: 5000)
+     */
+    urlsPerSitemap?: number;
+    /**
+     * Path to the app directory relative to the project root
+     * Default: "./src/app" or "./app"
+     */
+    appDir?: string;
+    /**
+     * Locale segment in the URL path (e.g., "[locale]")
+     * Auto-detected as "[locale]" when locales or defaultLocale is set
+     */
+    localeSegment?: string;
+    /**
+     * Exclude routes from the sitemap
+     * Can be an array of glob patterns or a function that returns true to exclude
+     * @example exclude: ["/admin/*", "/api/*"]
+     * @example exclude: (path) => path.startsWith("/private")
+     */
+    exclude?: string[] | ((path: string) => boolean);
+    /**
+     * Priority for sitemap entries
+     * Can be a fixed number (0.0-1.0), a function, or "auto" for depth-based calculation
+     * Default: "auto" (1.0 - depth * 0.2, minimum 0.1)
+     * @example priority: 0.8
+     * @example priority: (path) => path === "/" ? 1.0 : 0.7
+     * @example priority: "auto"
+     */
+    priority?: number | "auto" | ((path: string) => number);
+    /**
+     * Change frequency for sitemap entries
+     * Can be a fixed value or a function
+     * Default: "weekly"
+     * @example changeFreq: "daily"
+     * @example changeFreq: (path) => path === "/" ? "daily" : "weekly"
+     */
+    changeFreq?: ChangeFrequency | ((path: string) => ChangeFrequency);
+    /**
+     * Additional sitemaps to include in the sitemap index
+     * Useful for custom sitemaps (e.g., products from an API)
+     * @example additionalSitemaps: ["/products-sitemap.xml", "/blog-sitemap.xml"]
+     */
+    additionalSitemaps?: string[];
+}
+interface SitemapEntry {
+    url: string;
+    lastModified?: string | Date;
+    changeFrequency?: ChangeFrequency;
+    priority?: number;
+    alternates?: {
+        languages?: Record<string, string>;
+    };
+}
+type PageModule = {
+    generateStaticParams?: () => Promise<Record<string, string>[]>;
+};
+
+interface CreateSitemapApiHandlerOptions extends SitemapConfig {
+    /**
+     * The require.context result for page discovery
+     * Example: require.context('./', true, /^\.\/(?!\[|_|api\/).*\.tsx$/)
+     */
+    pagesContext: {
+        keys: () => string[];
+        (key: string): PageModule;
+    };
+    /**
+     * Enable debug logging to diagnose issues with route discovery
+     * Logs info about getStaticPaths calls and skipped routes
+     * @default false
+     */
+    debug?: boolean;
+}
+/**
+ * Create API handler for sitemap index route
+ * Use in: pages/api/sitemap.xml.ts or pages/sitemap.xml.ts (with rewrites)
+ */
+declare function createSitemapIndexApiHandler(options: CreateSitemapApiHandlerOptions): (_req: NextApiRequest, res: NextApiResponse) => Promise<void>;
+/**
+ * Create API handler for individual sitemap routes
+ * Use in: pages/api/sitemap/[id].ts or pages/sitemap-[id].xml.ts (with rewrites)
+ */
+declare function createSitemapApiHandler(options: CreateSitemapApiHandlerOptions): (req: NextApiRequest, res: NextApiResponse) => Promise<void>;
+/**
+ * Get the list of sitemap IDs for getStaticPaths
+ * Use this to pre-render sitemap pages at build time
+ */
+declare function getSitemapStaticPaths(options: CreateSitemapApiHandlerOptions): Promise<{
+    paths: {
+        params: {
+            id: string;
+        };
+    }[];
+    fallback: boolean;
+}>;
+
+export { type ChangeFrequency, type CreateSitemapApiHandlerOptions, type SitemapConfig, type SitemapEntry, createSitemapApiHandler, createSitemapIndexApiHandler, getSitemapStaticPaths };

package/dist/pages/index.js

@@ -0,0 +1,263 @@
+// src/index.ts
+function calculateDepthPriority(pathname) {
+  if (pathname === "/") return 1;
+  const depth = pathname.split("/").filter(Boolean).length;
+  return Math.max(0.1, 1 - depth * 0.2);
+}
+function shouldExclude(pathname, exclude) {
+  if (!exclude) return false;
+  if (typeof exclude === "function") {
+    return exclude(pathname);
+  }
+  return exclude.some((pattern) => {
+    const regexPattern = pattern.replace(/\*\*/g, "{{DOUBLE_STAR}}").replace(/\*/g, "[^/]*").replace(/\{\{DOUBLE_STAR\}\}/g, ".*");
+    const regex = new RegExp(`^${regexPattern}$`);
+    return regex.test(pathname);
+  });
+}
+function getPriority(pathname, priority) {
+  if (priority === void 0 || priority === "auto") {
+    return calculateDepthPriority(pathname);
+  }
+  if (typeof priority === "function") {
+    return priority(pathname);
+  }
+  return priority;
+}
+function getChangeFreq(pathname, changeFreq) {
+  if (changeFreq === void 0) {
+    return "weekly";
+  }
+  if (typeof changeFreq === "function") {
+    return changeFreq(pathname);
+  }
+  return changeFreq;
+}
+function buildUrl(baseUrl, pathname, locale, defaultLocale) {
+  if (!locale || locale === defaultLocale) {
+    return `${baseUrl}${pathname}`;
+  }
+  return `${baseUrl}/${locale}${pathname}`;
+}
+function generateSitemapXml(entries) {
+  const hasAlternates = entries.some((e) => e.alternates?.languages);
+  const xmlns = hasAlternates ? 'xmlns="http://www.sitemaps.org/schemas/sitemap/0.9" xmlns:xhtml="http://www.w3.org/1999/xhtml"' : 'xmlns="http://www.sitemaps.org/schemas/sitemap/0.9"';
+  const urlEntries = entries.map((entry) => {
+    const parts = [`    <loc>${entry.url}</loc>`];
+    if (entry.alternates?.languages) {
+      for (const [lang, href] of Object.entries(entry.alternates.languages)) {
+        parts.push(`    <xhtml:link rel="alternate" hreflang="${lang}" href="${href}" />`);
+      }
+    }
+    if (entry.lastModified) {
+      const date = entry.lastModified instanceof Date ? entry.lastModified.toISOString() : entry.lastModified;
+      parts.push(`    <lastmod>${date}</lastmod>`);
+    }
+    if (entry.changeFrequency) {
+      parts.push(`    <changefreq>${entry.changeFrequency}</changefreq>`);
+    }
+    if (entry.priority !== void 0) {
+      parts.push(`    <priority>${entry.priority}</priority>`);
+    }
+    return `  <url>
+${parts.join("\n")}
+  </url>`;
+  }).join("\n");
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<urlset ${xmlns}>
+${urlEntries}
+</urlset>`;
+}
+function generateSitemapIndexXml(baseUrl, sitemapCount, options) {
+  const { sitemapPattern = "/sitemap-{id}.xml", additionalSitemaps = [] } = options || {};
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const paginatedEntries = Array.from({ length: sitemapCount }, (_, i) => {
+    const loc = `${baseUrl}${sitemapPattern.replace("{id}", String(i))}`;
+    return `  <sitemap>
+    <loc>${loc}</loc>
+    <lastmod>${now}</lastmod>
+  </sitemap>`;
+  });
+  const additionalEntries = additionalSitemaps.map((sitemap) => {
+    const loc = sitemap.startsWith("http") ? sitemap : `${baseUrl}${sitemap}`;
+    return `  <sitemap>
+    <loc>${loc}</loc>
+    <lastmod>${now}</lastmod>
+  </sitemap>`;
+  });
+  const allEntries = [...paginatedEntries, ...additionalEntries].join("\n");
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+${allEntries}
+</sitemapindex>`;
+}
+
+// src/pages/index.ts
+function extractRoutes(pagesContext, localeSegment) {
+  const routes = [];
+  for (const key of pagesContext.keys()) {
+    if (key.includes("[...")) continue;
+    if (key.includes("/api/")) continue;
+    if (key.includes("/_")) continue;
+    const pageModule = pagesContext(key);
+    let pathname = key.replace(/^\.\//, "/").replace(/\.tsx?$/, "").replace(/\/index$/, "/");
+    if (pathname === "") pathname = "/";
+    if (localeSegment) {
+      pathname = pathname.replace(
+        new RegExp(`^/${localeSegment.replace(/[[\]]/g, "\\$&")}`),
+        ""
+      );
+    }
+    if (/(?:^|\/)(src|pages)(?:\/|$)/.test(pathname)) continue;
+    if (!pathname || pathname === "") {
+      pathname = "/";
+    } else if (!pathname.startsWith("/")) {
+      pathname = "/" + pathname;
+    }
+    const dynamicSegments = pathname.match(/\[([^\]]+)\]/g)?.map((s) => s.slice(1, -1)) || [];
+    const getStaticPaths = pageModule.getStaticPaths;
+    let getParams = null;
+    if (getStaticPaths) {
+      getParams = async () => {
+        const result = await getStaticPaths();
+        return result.paths.map((p) => p.params);
+      };
+    } else if (pageModule.generateStaticParams) {
+      getParams = pageModule.generateStaticParams;
+    }
+    routes.push({
+      pathname,
+      dynamicSegments,
+      getParams
+    });
+  }
+  return routes;
+}
+async function getAllPaths(routes, debug = false) {
+  const allPaths = ["/"];
+  const seenPaths = /* @__PURE__ */ new Set(["/"]);
+  for (const route of routes) {
+    if (route.dynamicSegments.length === 0) {
+      if (route.pathname !== "/" && !seenPaths.has(route.pathname)) {
+        allPaths.push(route.pathname);
+        seenPaths.add(route.pathname);
+      }
+    } else if (route.getParams) {
+      try {
+        const params = await route.getParams();
+        if (debug) {
+          console.log(`[next-sitemap] ${route.pathname}: getStaticPaths returned ${params.length} params`);
+        }
+        for (const param of params) {
+          let dynamicPath = route.pathname;
+          for (const segment of route.dynamicSegments) {
+            const value = param[segment];
+            if (value === void 0) {
+              if (debug) {
+                console.warn(`[next-sitemap] ${route.pathname}: missing param "${segment}" in`, param);
+              }
+              continue;
+            }
+            dynamicPath = dynamicPath.replace(`[${segment}]`, value);
+          }
+          if (!seenPaths.has(dynamicPath)) {
+            allPaths.push(dynamicPath);
+            seenPaths.add(dynamicPath);
+          }
+        }
+      } catch (error) {
+        console.error(`[next-sitemap] Error calling getStaticPaths for ${route.pathname}:`, error);
+      }
+    } else if (route.dynamicSegments.length > 0) {
+      if (debug) {
+        console.warn(
+          `[next-sitemap] Skipping dynamic route ${route.pathname}: no getStaticPaths exported. Use additionalSitemaps for routes that fetch data at runtime.`
+        );
+      }
+    }
+  }
+  return allPaths;
+}
+function pathsToEntries(paths, config) {
+  const { baseUrl, locales = [], defaultLocale, exclude, priority, changeFreq } = config;
+  const filteredPaths = paths.filter((pathname) => !shouldExclude(pathname, exclude));
+  return filteredPaths.map((pathname) => {
+    const entry = {
+      url: buildUrl(baseUrl, pathname, defaultLocale, defaultLocale),
+      lastModified: /* @__PURE__ */ new Date(),
+      changeFrequency: getChangeFreq(pathname, changeFreq),
+      priority: getPriority(pathname, priority)
+    };
+    if (locales.length > 0) {
+      entry.alternates = {
+        languages: Object.fromEntries(
+          locales.map((locale) => [
+            locale,
+            buildUrl(baseUrl, pathname, locale, defaultLocale)
+          ])
+        )
+      };
+    }
+    return entry;
+  });
+}
+function createSitemapIndexApiHandler(options) {
+  const { urlsPerSitemap = 5e3, additionalSitemaps, exclude, debug = false } = options;
+  const localeSegment = options.localeSegment ?? "";
+  const routes = extractRoutes(options.pagesContext, localeSegment);
+  if (debug) {
+    console.log(`[next-sitemap] Found ${routes.length} routes:`);
+    routes.forEach((r) => {
+      const hasParams = r.getParams ? "\u2713 getStaticPaths" : "\u2717 no getStaticPaths";
+      const segments = r.dynamicSegments.length > 0 ? ` [${r.dynamicSegments.join(", ")}]` : "";
+      console.log(`  ${r.pathname}${segments} - ${hasParams}`);
+    });
+  }
+  return async function handler(_req, res) {
+    const allPaths = await getAllPaths(routes, debug);
+    const filteredPaths = allPaths.filter((pathname) => !shouldExclude(pathname, exclude));
+    const sitemapCount = Math.max(1, Math.ceil(filteredPaths.length / urlsPerSitemap));
+    const xml = generateSitemapIndexXml(options.baseUrl, sitemapCount, {
+      additionalSitemaps
+    });
+    res.setHeader("Content-Type", "application/xml");
+    res.status(200).send(xml);
+  };
+}
+function createSitemapApiHandler(options) {
+  const { urlsPerSitemap = 5e3, exclude, debug = false } = options;
+  const localeSegment = options.localeSegment ?? "";
+  const routes = extractRoutes(options.pagesContext, localeSegment);
+  const getFilteredPaths = async () => {
+    const allPaths = await getAllPaths(routes, debug);
+    return allPaths.filter((pathname) => !shouldExclude(pathname, exclude));
+  };
+  return async function handler(req, res) {
+    const { id } = req.query;
+    const sitemapId = parseInt(Array.isArray(id) ? id[0] : id || "0", 10);
+    const filteredPaths = await getFilteredPaths();
+    const start = sitemapId * urlsPerSitemap;
+    const end = start + urlsPerSitemap;
+    const paths = filteredPaths.slice(start, end);
+    const entries = pathsToEntries(paths, { ...options, exclude: void 0 });
+    const xml = generateSitemapXml(entries);
+    res.setHeader("Content-Type", "application/xml");
+    res.status(200).send(xml);
+  };
+}
+async function getSitemapStaticPaths(options) {
+  const { urlsPerSitemap = 5e3, exclude, debug = false } = options;
+  const localeSegment = options.localeSegment ?? "";
+  const routes = extractRoutes(options.pagesContext, localeSegment);
+  const allPaths = await getAllPaths(routes, debug);
+  const filteredPaths = allPaths.filter((pathname) => !shouldExclude(pathname, exclude));
+  const sitemapCount = Math.max(1, Math.ceil(filteredPaths.length / urlsPerSitemap));
+  return {
+    paths: Array.from({ length: sitemapCount }, (_, i) => ({
+      params: { id: String(i) }
+    })),
+    fallback: false
+  };
+}
+
+export { createSitemapApiHandler, createSitemapIndexApiHandler, getSitemapStaticPaths };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onruntime/next-sitemap",
-  "version": "0.2.1",
+  "version": "0.4.0",
   "description": "Dynamic sitemap generation for Next.js with automatic route discovery",
   "author": "onRuntime Studio <contact@onruntime.com>",
   "repository": {
@@ -28,6 +28,11 @@
       "types": "./dist/app/index.d.ts",
       "import": "./dist/app/index.js",
       "require": "./dist/app/index.cjs"
+    },
+    "./pages": {
+      "types": "./dist/pages/index.d.ts",
+      "import": "./dist/pages/index.js",
+      "require": "./dist/pages/index.cjs"
     }
   },
   "files": [
@@ -46,6 +51,7 @@
     "sitemap",
     "nextjs",
     "app-router",
+    "pages-router",
     "seo",
     "xml",
     "dynamic-sitemap"