@onruntime/next-sitemap 0.1.0

package/README.md

@@ -0,0 +1,271 @@
+# @onruntime/next-sitemap
+
+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)
+
+## Features
+
+- Automatic route discovery using `require.context`
+- Calls `generateStaticParams` for dynamic routes
+- Multi-sitemap support with sitemap index (for sites with >50,000 URLs)
+- hreflang alternates for i18n
+- Fully static generation (SSG)
+
+## Installation
+
+```bash
+pnpm add @onruntime/next-sitemap
+```
+
+## Usage
+
+### Next.js App Router
+
+#### 1. Create the sitemap index route
+
+```typescript
+// app/sitemap.xml/route.ts
+import { createSitemapIndexHandler } from "@onruntime/next-sitemap/app";
+
+export const dynamic = "force-static";
+
+// @ts-expect-error - require.context is a webpack/turbopack feature
+const pagesContext = require.context("../", true, /\/page\.tsx$/);
+
+const { GET } = createSitemapIndexHandler({
+  baseUrl: "https://example.com",
+  pagesContext,
+});
+
+export { GET };
+```
+
+#### 2. Create the individual sitemap route
+
+```typescript
+// app/sitemap.xml/[id]/route.ts
+import { createSitemapHandler } from "@onruntime/next-sitemap/app";
+
+export const dynamic = "force-static";
+
+// @ts-expect-error - require.context is a webpack/turbopack feature
+const pagesContext = require.context("../../", true, /\/page\.tsx$/);
+
+const { generateStaticParams, GET } = createSitemapHandler({
+  baseUrl: "https://example.com",
+  pagesContext,
+});
+
+export { generateStaticParams, GET };
+```
+
+#### With i18n (optional)
+
+If your app uses a `[locale]` segment for internationalization, just add `locales` and `defaultLocale`. The `localeSegment` is automatically set to `"[locale]"`:
+
+```typescript
+// app/sitemap.xml/route.ts
+const pagesContext = require.context("../[locale]", true, /\/page\.tsx$/);
+
+const { GET } = createSitemapIndexHandler({
+  baseUrl: "https://example.com",
+  locales: ["en", "fr"],
+  defaultLocale: "en",
+  pagesContext,
+});
+```
+
+If you use a different segment name (e.g., `[lang]`), specify it explicitly:
+
+```typescript
+localeSegment: "[lang]", // Custom segment name
+```
+
+#### 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-:id.xml",
+        destination: "/sitemap.xml/:id",
+      },
+    ];
+  },
+};
+
+export default nextConfig;
+```
+
+### Configuration Options
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `baseUrl` | `string` | required | Base URL of the site |
+| `locales` | `string[]` | `[]` | List of supported locales |
+| `defaultLocale` | `string` | `undefined` | Default locale (URLs without prefix) |
+| `urlsPerSitemap` | `number` | `5000` | Max URLs per sitemap file |
+| `localeSegment` | `string` | auto | Auto-detected as `"[locale]"` when i18n is configured. Override for custom names like `"[lang]"`. |
+| `pagesContext` | `object` | required | Result of `require.context()` |
+| `exclude` | `string[]` or `function` | `undefined` | Patterns or function to exclude routes |
+| `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 |
+
+#### Exclude Routes
+
+Exclude specific routes from the sitemap using glob patterns or a function:
+
+```typescript
+// Using glob patterns
+const { GET } = createSitemapIndexHandler({
+  baseUrl: "https://example.com",
+  pagesContext,
+  exclude: ["/admin/*", "/api/*", "/private/**"],
+});
+
+// Using a function
+const { GET } = createSitemapIndexHandler({
+  baseUrl: "https://example.com",
+  pagesContext,
+  exclude: (path) => path.startsWith("/internal"),
+});
+```
+
+#### Priority
+
+By default, priority is calculated automatically based on URL depth:
+- `/` → 1.0
+- `/about` → 0.8
+- `/blog/post` → 0.6
+- Minimum: 0.1
+
+You can override with a fixed value or a function:
+
+```typescript
+// Fixed priority for all URLs
+priority: 0.8,
+
+// Custom function
+priority: (path) => {
+  if (path === "/") return 1.0;
+  if (path.startsWith("/products")) return 0.9;
+  return 0.5;
+},
+```
+
+#### Change Frequency
+
+Set a default change frequency or customize per route:
+
+```typescript
+// Fixed value
+changeFreq: "daily",
+
+// Custom function
+changeFreq: (path) => {
+  if (path === "/") return "daily";
+  if (path.startsWith("/blog")) return "weekly";
+  return "monthly";
+},
+```
+
+#### Additional Sitemaps
+
+Include custom sitemaps in the sitemap index (e.g., for API-fetched data):
+
+```typescript
+const { GET } = createSitemapIndexHandler({
+  baseUrl: "https://example.com",
+  pagesContext,
+  additionalSitemaps: ["/products-sitemap.xml", "/blog-sitemap.xml"],
+});
+```
+
+### How It Works
+
+1. `require.context` scans your app 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`
+4. URLs are paginated into multiple sitemaps (default: 5000 URLs each)
+5. A sitemap index lists all individual sitemaps
+
+### Generated URLs
+
+For a route structure like:
+```
+app/
+├── page.tsx                    → /
+├── about/page.tsx              → /about
+├── posts/page.tsx              → /posts
+└── posts/[slug]/page.tsx       → /posts/hello-world, /posts/getting-started, ...
+```
+
+The sitemap will include:
+- All static routes
+- All dynamic routes resolved via `generateStaticParams`
+- hreflang alternates for each locale (if i18n is configured)
+
+**Note:** Dynamic routes without `generateStaticParams` are skipped. If you need to include routes that fetch data at runtime (e.g., from an API), you can create a separate sitemap using [Next.js native sitemap generation](https://nextjs.org/docs/app/api-reference/file-conventions/metadata/sitemap):
+
+```typescript
+// app/custom-sitemap.xml/route.ts
+import { generateSitemapXml } from "@onruntime/next-sitemap";
+
+export async function GET() {
+  // Fetch your dynamic data
+  const products = await fetch("https://api.example.com/products").then(r => r.json());
+
+  const entries = products.map((p: { slug: string }) => ({
+    url: `https://example.com/products/${p.slug}`,
+    lastModified: new Date(),
+  }));
+
+  return new Response(generateSitemapXml(entries), {
+    headers: { "Content-Type": "application/xml" },
+  });
+}
+```
+
+### Example Output
+
+**Sitemap Index** (`/sitemap.xml`):
+```xml
+<?xml version="1.0" encoding="UTF-8"?>
+<sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+  <sitemap>
+    <loc>https://example.com/sitemap-0.xml</loc>
+    <lastmod>2024-01-01T00:00:00.000Z</lastmod>
+  </sitemap>
+</sitemapindex>
+```
+
+**Individual Sitemap** (`/sitemap-0.xml`):
+```xml
+<?xml version="1.0" encoding="UTF-8"?>
+<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+  <url>
+    <loc>https://example.com/</loc>
+    <lastmod>2024-01-01T00:00:00.000Z</lastmod>
+    <changefreq>weekly</changefreq>
+    <priority>1</priority>
+  </url>
+  <url>
+    <loc>https://example.com/posts/hello-world</loc>
+    <lastmod>2024-01-01T00:00:00.000Z</lastmod>
+    <changefreq>weekly</changefreq>
+    <priority>0.7</priority>
+  </url>
+</urlset>
+```
+
+## License
+
+MIT

package/dist/app/index.cjs

@@ -0,0 +1,211 @@
+'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/app/index.ts
+function extractRoutes(pagesContext, localeSegment) {
+  const routes = [];
+  for (const key of pagesContext.keys()) {
+    if (key.includes("[...")) continue;
+    const pageModule = pagesContext(key);
+    let pathname = key.replace("./", "/").replace("/page.tsx", "").replace(new RegExp(`^/${localeSegment.replace(/[[\]]/g, "\\$&")}`), "").replace(/\/\([^)]+\)/g, "") || "/";
+    if (pathname === "") pathname = "/";
+    const dynamicSegments = pathname.match(/\[([^\]]+)\]/g)?.map((s) => s.slice(1, -1)) || [];
+    routes.push({
+      pathname,
+      dynamicSegments,
+      getParams: pageModule.generateStaticParams || null
+    });
+  }
+  return routes;
+}
+async function getAllPaths(routes) {
+  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) {
+      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]);
+        }
+        if (!seenPaths.has(dynamicPath)) {
+          allPaths.push(dynamicPath);
+          seenPaths.add(dynamicPath);
+        }
+      }
+    }
+  }
+  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 createSitemapIndexHandler(options) {
+  const { urlsPerSitemap = 5e3, locales = [], defaultLocale, additionalSitemaps, exclude } = options;
+  const localeSegment = options.localeSegment ?? (locales.length > 0 || defaultLocale ? "[locale]" : "");
+  const routes = extractRoutes(options.pagesContext, localeSegment);
+  return {
+    GET: async () => {
+      const allPaths = await getAllPaths(routes);
+      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
+      });
+      return new Response(xml, {
+        headers: { "Content-Type": "application/xml" }
+      });
+    }
+  };
+}
+function createSitemapHandler(options) {
+  const { urlsPerSitemap = 5e3, locales = [], defaultLocale, exclude } = options;
+  const localeSegment = options.localeSegment ?? (locales.length > 0 || defaultLocale ? "[locale]" : "");
+  const routes = extractRoutes(options.pagesContext, localeSegment);
+  const getFilteredPaths = async () => {
+    const allPaths = await getAllPaths(routes);
+    return allPaths.filter((pathname) => !shouldExclude(pathname, exclude));
+  };
+  return {
+    generateStaticParams: async () => {
+      const filteredPaths = await getFilteredPaths();
+      const sitemapCount = Math.max(1, Math.ceil(filteredPaths.length / urlsPerSitemap));
+      return Array.from({ length: sitemapCount }, (_, i) => ({ id: String(i) }));
+    },
+    GET: async (_request, { params }) => {
+      const { id } = await params;
+      const sitemapId = parseInt(id, 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);
+      return new Response(xml, {
+        headers: { "Content-Type": "application/xml" }
+      });
+    }
+  };
+}
+
+exports.createSitemapHandler = createSitemapHandler;
+exports.createSitemapIndexHandler = createSitemapIndexHandler;

package/dist/app/index.d.cts

@@ -0,0 +1,105 @@
+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 CreateSitemapHandlerOptions extends SitemapConfig {
+    /**
+     * The require.context result for page discovery
+     * Example: require.context('./[locale]', true, /\/page\.tsx$/)
+     */
+    pagesContext: {
+        keys: () => string[];
+        (key: string): PageModule;
+    };
+}
+/**
+ * Create handlers for sitemap index route
+ * Use in: app/sitemap.xml/route.ts
+ */
+declare function createSitemapIndexHandler(options: CreateSitemapHandlerOptions): {
+    GET: () => Promise<Response>;
+};
+/**
+ * Create handlers for individual sitemap routes
+ * Use in: app/sitemap.xml/[id]/route.ts
+ */
+declare function createSitemapHandler(options: CreateSitemapHandlerOptions): {
+    generateStaticParams: () => Promise<{
+        id: string;
+    }[]>;
+    GET: (_request: Request, { params }: {
+        params: Promise<{
+            id: string;
+        }>;
+    }) => Promise<Response>;
+};
+
+export { type ChangeFrequency, type CreateSitemapHandlerOptions, type SitemapConfig, type SitemapEntry, createSitemapHandler, createSitemapIndexHandler };

package/dist/app/index.d.ts

@@ -0,0 +1,105 @@
+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 CreateSitemapHandlerOptions extends SitemapConfig {
+    /**
+     * The require.context result for page discovery
+     * Example: require.context('./[locale]', true, /\/page\.tsx$/)
+     */
+    pagesContext: {
+        keys: () => string[];
+        (key: string): PageModule;
+    };
+}
+/**
+ * Create handlers for sitemap index route
+ * Use in: app/sitemap.xml/route.ts
+ */
+declare function createSitemapIndexHandler(options: CreateSitemapHandlerOptions): {
+    GET: () => Promise<Response>;
+};
+/**
+ * Create handlers for individual sitemap routes
+ * Use in: app/sitemap.xml/[id]/route.ts
+ */
+declare function createSitemapHandler(options: CreateSitemapHandlerOptions): {
+    generateStaticParams: () => Promise<{
+        id: string;
+    }[]>;
+    GET: (_request: Request, { params }: {
+        params: Promise<{
+            id: string;
+        }>;
+    }) => Promise<Response>;
+};
+
+export { type ChangeFrequency, type CreateSitemapHandlerOptions, type SitemapConfig, type SitemapEntry, createSitemapHandler, createSitemapIndexHandler };

package/dist/app/index.js

@@ -0,0 +1,208 @@
+// 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/app/index.ts
+function extractRoutes(pagesContext, localeSegment) {
+  const routes = [];
+  for (const key of pagesContext.keys()) {
+    if (key.includes("[...")) continue;
+    const pageModule = pagesContext(key);
+    let pathname = key.replace("./", "/").replace("/page.tsx", "").replace(new RegExp(`^/${localeSegment.replace(/[[\]]/g, "\\$&")}`), "").replace(/\/\([^)]+\)/g, "") || "/";
+    if (pathname === "") pathname = "/";
+    const dynamicSegments = pathname.match(/\[([^\]]+)\]/g)?.map((s) => s.slice(1, -1)) || [];
+    routes.push({
+      pathname,
+      dynamicSegments,
+      getParams: pageModule.generateStaticParams || null
+    });
+  }
+  return routes;
+}
+async function getAllPaths(routes) {
+  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) {
+      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]);
+        }
+        if (!seenPaths.has(dynamicPath)) {
+          allPaths.push(dynamicPath);
+          seenPaths.add(dynamicPath);
+        }
+      }
+    }
+  }
+  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 createSitemapIndexHandler(options) {
+  const { urlsPerSitemap = 5e3, locales = [], defaultLocale, additionalSitemaps, exclude } = options;
+  const localeSegment = options.localeSegment ?? (locales.length > 0 || defaultLocale ? "[locale]" : "");
+  const routes = extractRoutes(options.pagesContext, localeSegment);
+  return {
+    GET: async () => {
+      const allPaths = await getAllPaths(routes);
+      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
+      });
+      return new Response(xml, {
+        headers: { "Content-Type": "application/xml" }
+      });
+    }
+  };
+}
+function createSitemapHandler(options) {
+  const { urlsPerSitemap = 5e3, locales = [], defaultLocale, exclude } = options;
+  const localeSegment = options.localeSegment ?? (locales.length > 0 || defaultLocale ? "[locale]" : "");
+  const routes = extractRoutes(options.pagesContext, localeSegment);
+  const getFilteredPaths = async () => {
+    const allPaths = await getAllPaths(routes);
+    return allPaths.filter((pathname) => !shouldExclude(pathname, exclude));
+  };
+  return {
+    generateStaticParams: async () => {
+      const filteredPaths = await getFilteredPaths();
+      const sitemapCount = Math.max(1, Math.ceil(filteredPaths.length / urlsPerSitemap));
+      return Array.from({ length: sitemapCount }, (_, i) => ({ id: String(i) }));
+    },
+    GET: async (_request, { params }) => {
+      const { id } = await params;
+      const sitemapId = parseInt(id, 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);
+      return new Response(xml, {
+        headers: { "Content-Type": "application/xml" }
+      });
+    }
+  };
+}
+
+export { createSitemapHandler, createSitemapIndexHandler };

package/dist/index.cjs

@@ -0,0 +1,103 @@
+'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>`;
+}
+
+exports.buildUrl = buildUrl;
+exports.calculateDepthPriority = calculateDepthPriority;
+exports.generateSitemapIndexXml = generateSitemapIndexXml;
+exports.generateSitemapXml = generateSitemapXml;
+exports.getChangeFreq = getChangeFreq;
+exports.getPriority = getPriority;
+exports.shouldExclude = shouldExclude;

package/dist/index.d.cts

@@ -0,0 +1,111 @@
+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>;
+    };
+}
+/**
+ * Calculate priority based on URL depth
+ * Root (/) = 1.0, /about = 0.8, /blog/post = 0.6, etc.
+ * Minimum priority is 0.1
+ */
+declare function calculateDepthPriority(pathname: string): number;
+/**
+ * Check if a path should be excluded based on patterns or function
+ */
+declare function shouldExclude(pathname: string, exclude?: string[] | ((path: string) => boolean)): boolean;
+/**
+ * Get priority for a pathname based on config
+ */
+declare function getPriority(pathname: string, priority?: number | "auto" | ((path: string) => number)): number;
+/**
+ * Get change frequency for a pathname based on config
+ */
+declare function getChangeFreq(pathname: string, changeFreq?: ChangeFrequency | ((path: string) => ChangeFrequency)): ChangeFrequency;
+interface RouteInfo {
+    pathname: string;
+    dynamicSegments: string[];
+    hasGenerateStaticParams: boolean;
+}
+type PageModule = {
+    generateStaticParams?: () => Promise<Record<string, string>[]>;
+};
+/**
+ * Generate the full URL for a pathname
+ */
+declare function buildUrl(baseUrl: string, pathname: string, locale?: string, defaultLocale?: string): string;
+/**
+ * Generate sitemap XML from entries
+ */
+declare function generateSitemapXml(entries: SitemapEntry[]): string;
+/**
+ * Generate sitemap index XML
+ */
+declare function generateSitemapIndexXml(baseUrl: string, sitemapCount: number, options?: {
+    sitemapPattern?: string;
+    additionalSitemaps?: string[];
+}): string;
+
+export { type ChangeFrequency, type PageModule, type RouteInfo, type SitemapConfig, type SitemapEntry, buildUrl, calculateDepthPriority, generateSitemapIndexXml, generateSitemapXml, getChangeFreq, getPriority, shouldExclude };

package/dist/index.d.ts

@@ -0,0 +1,111 @@
+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>;
+    };
+}
+/**
+ * Calculate priority based on URL depth
+ * Root (/) = 1.0, /about = 0.8, /blog/post = 0.6, etc.
+ * Minimum priority is 0.1
+ */
+declare function calculateDepthPriority(pathname: string): number;
+/**
+ * Check if a path should be excluded based on patterns or function
+ */
+declare function shouldExclude(pathname: string, exclude?: string[] | ((path: string) => boolean)): boolean;
+/**
+ * Get priority for a pathname based on config
+ */
+declare function getPriority(pathname: string, priority?: number | "auto" | ((path: string) => number)): number;
+/**
+ * Get change frequency for a pathname based on config
+ */
+declare function getChangeFreq(pathname: string, changeFreq?: ChangeFrequency | ((path: string) => ChangeFrequency)): ChangeFrequency;
+interface RouteInfo {
+    pathname: string;
+    dynamicSegments: string[];
+    hasGenerateStaticParams: boolean;
+}
+type PageModule = {
+    generateStaticParams?: () => Promise<Record<string, string>[]>;
+};
+/**
+ * Generate the full URL for a pathname
+ */
+declare function buildUrl(baseUrl: string, pathname: string, locale?: string, defaultLocale?: string): string;
+/**
+ * Generate sitemap XML from entries
+ */
+declare function generateSitemapXml(entries: SitemapEntry[]): string;
+/**
+ * Generate sitemap index XML
+ */
+declare function generateSitemapIndexXml(baseUrl: string, sitemapCount: number, options?: {
+    sitemapPattern?: string;
+    additionalSitemaps?: string[];
+}): string;
+
+export { type ChangeFrequency, type PageModule, type RouteInfo, type SitemapConfig, type SitemapEntry, buildUrl, calculateDepthPriority, generateSitemapIndexXml, generateSitemapXml, getChangeFreq, getPriority, shouldExclude };

package/dist/index.js

@@ -0,0 +1,95 @@
+// 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>`;
+}
+
+export { buildUrl, calculateDepthPriority, generateSitemapIndexXml, generateSitemapXml, getChangeFreq, getPriority, shouldExclude };

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "@onruntime/next-sitemap",
+  "version": "0.1.0",
+  "description": "Dynamic sitemap generation for Next.js with automatic route discovery",
+  "author": "onRuntime Studio <contact@onruntime.com>",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/onRuntime/onruntime.git",
+    "directory": "packages/next-sitemap"
+  },
+  "homepage": "https://github.com/onRuntime/onruntime/tree/master/packages/next-sitemap#readme",
+  "bugs": {
+    "url": "https://github.com/onRuntime/onruntime/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    },
+    "./app": {
+      "types": "./dist/app/index.d.ts",
+      "import": "./dist/app/index.js",
+      "require": "./dist/app/index.cjs"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "type-check": "tsc --noEmit"
+  },
+  "peerDependencies": {
+    "next": ">=14.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "next": "^16.1.1",
+    "tsup": "^8",
+    "typescript": "^5"
+  },
+  "keywords": [
+    "sitemap",
+    "nextjs",
+    "app-router",
+    "seo",
+    "xml",
+    "dynamic-sitemap"
+  ],
+  "license": "MIT"
+}