@djangocfg/nextjs 2.1.109 → 2.1.111

package/src/sitemap/generator.ts

@@ -2,32 +2,107 @@
  * Sitemap Generator
  *
  * Generates XML sitemap from configuration
+ * Supports i18n with hreflang tags for multilingual sites
  */
 
 import type { SitemapUrl } from '../types';
+import type { SitemapI18nOptions } from './types';
+
+export interface GenerateSitemapXmlOptions {
+  urls: SitemapUrl[];
+  i18n?: SitemapI18nOptions;
+  siteUrl: string;
+}
 
 /**
  * Generate XML sitemap string from URLs
+ * Supports i18n with hreflang alternate links
  */
-export function generateSitemapXml(urls: SitemapUrl[]): string {
-  return `<?xml version="1.0" encoding="UTF-8"?>
-<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9"
+export function generateSitemapXml(
+  urlsOrOptions: SitemapUrl[] | GenerateSitemapXmlOptions
+): string {
+  // Support both old signature (just urls) and new signature (options object)
+  const isOptionsObject = !Array.isArray(urlsOrOptions);
+  const urls = isOptionsObject ? urlsOrOptions.urls : urlsOrOptions;
+  const i18n = isOptionsObject ? urlsOrOptions.i18n : undefined;
+  const siteUrl = isOptionsObject ? urlsOrOptions.siteUrl : '';
+
+  // Add xhtml namespace if i18n is enabled
+  const namespaces = i18n
+    ? `xmlns="http://www.sitemaps.org/schemas/sitemap/0.9"
+        xmlns:xhtml="http://www.w3.org/1999/xhtml"
+        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+        xsi:schemaLocation="http://www.sitemaps.org/schemas/sitemap/0.9
+        http://www.sitemaps.org/schemas/sitemap/0.9/sitemap.xsd"`
+    : `xmlns="http://www.sitemaps.org/schemas/sitemap/0.9"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://www.sitemaps.org/schemas/sitemap/0.9
-        http://www.sitemaps.org/schemas/sitemap/0.9/sitemap.xsd">
+        http://www.sitemaps.org/schemas/sitemap/0.9/sitemap.xsd"`;
+
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<urlset ${namespaces}>
 ${urls
-  .map(
-    ({ loc, lastmod, changefreq, priority }) => `  <url>
-    <loc>${escapeXml(loc)}</loc>
+  .map(({ loc, lastmod, changefreq, priority }) => {
+    const hreflangLinks = i18n
+      ? generateHreflangLinks(loc, i18n, siteUrl)
+      : '';
+
+    return `  <url>
+    <loc>${escapeXml(loc)}</loc>${hreflangLinks}
     ${lastmod ? `<lastmod>${formatDate(lastmod)}</lastmod>` : ''}
     ${changefreq ? `<changefreq>${changefreq}</changefreq>` : ''}
     ${priority !== undefined ? `<priority>${priority.toFixed(1)}</priority>` : ''}
-  </url>`
-  )
+  </url>`;
+  })
   .join('\n')}
 </urlset>`;
 }
 
+/**
+ * Generate hreflang links for a URL
+ */
+function generateHreflangLinks(
+  loc: string,
+  i18n: SitemapI18nOptions,
+  siteUrl: string
+): string {
+  const { locales, defaultLocale } = i18n;
+
+  // Extract the path without locale prefix from the URL
+  // e.g., https://example.com/en/page -> /page
+  const baseSiteUrl = siteUrl.endsWith('/') ? siteUrl.slice(0, -1) : siteUrl;
+  let path = loc.replace(baseSiteUrl, '');
+
+  // Remove locale prefix if present
+  for (const locale of locales) {
+    const localePrefix = `/${locale}`;
+    if (path === localePrefix || path.startsWith(`${localePrefix}/`)) {
+      path = path.slice(localePrefix.length) || '/';
+      break;
+    }
+  }
+
+  const links: string[] = [];
+
+  // Add hreflang for each locale
+  for (const locale of locales) {
+    const localePath = path === '/' ? `/${locale}` : `/${locale}${path}`;
+    const fullUrl = `${baseSiteUrl}${localePath}`;
+    links.push(
+      `    <xhtml:link rel="alternate" hreflang="${locale}" href="${escapeXml(fullUrl)}"/>`
+    );
+  }
+
+  // Add x-default pointing to default locale
+  const defaultPath = path === '/' ? `/${defaultLocale}` : `/${defaultLocale}${path}`;
+  const defaultUrl = `${baseSiteUrl}${defaultPath}`;
+  links.push(
+    `    <xhtml:link rel="alternate" hreflang="x-default" href="${escapeXml(defaultUrl)}"/>`
+  );
+
+  return '\n' + links.join('\n');
+}
+
 /**
  * Format date for sitemap (ISO 8601)
  */

package/src/sitemap/index.ts

@@ -4,5 +4,5 @@
 
 export { createSitemapHandler } from './route';
 export { generateSitemapXml, normalizeUrl } from './generator';
-export type { SitemapGeneratorOptions, SitemapRoute } from './types';
+export type { SitemapGeneratorOptions, SitemapRoute, SitemapI18nOptions } from './types';
 

package/src/sitemap/route.ts

@@ -13,7 +13,6 @@
  *     { loc: '/about', changefreq: 'monthly', priority: 0.8 },
  *   ],
  *   dynamicPages: async () => {
- *     // Fetch dynamic pages from API
  *     const posts = await fetchPosts();
  *     return posts.map(post => ({
  *       loc: `/posts/${post.slug}`,
@@ -22,6 +21,11 @@
  *       priority: 0.7,
  *     }));
  *   },
+ *   // i18n support with hreflang
+ *   i18n: {
+ *     locales: ['en', 'ru', 'ko'],
+ *     defaultLocale: 'en',
+ *   },
  * });
  * ```
  */
@@ -39,6 +43,7 @@ export function createSitemapHandler(options: SitemapGeneratorOptions) {
     staticPages = [],
     dynamicPages = [],
     cacheControl = 'public, s-maxage=86400, stale-while-revalidate',
+    i18n,
   } = options;
 
   return async function GET() {
@@ -54,14 +59,23 @@ export function createSitemapHandler(options: SitemapGeneratorOptions) {
       }
     }
 
-    // Normalize all URLs
-    const normalizedUrls = urls.map((url) => ({
-      ...url,
-      loc: normalizeUrl(url.loc, siteUrl),
-    }));
+    // Expand URLs for each locale if i18n is enabled
+    let expandedUrls: SitemapUrl[];
+    if (i18n) {
+      expandedUrls = expandUrlsForLocales(urls, i18n.locales, siteUrl);
+    } else {
+      expandedUrls = urls.map((url) => ({
+        ...url,
+        loc: normalizeUrl(url.loc, siteUrl),
+      }));
+    }
 
-    // Generate XML
-    const sitemap = generateSitemapXml(normalizedUrls);
+    // Generate XML with i18n support
+    const sitemap = generateSitemapXml({
+      urls: expandedUrls,
+      i18n,
+      siteUrl,
+    });
 
     // Return response
     return new NextResponse(sitemap, {
@@ -74,3 +88,52 @@ export function createSitemapHandler(options: SitemapGeneratorOptions) {
   };
 }
 
+/**
+ * Expand URLs to include all locale variants
+ * Input: [{ loc: '/page' }] with locales ['en', 'ru']
+ * Output: [{ loc: 'https://example.com/en/page' }, { loc: 'https://example.com/ru/page' }]
+ */
+function expandUrlsForLocales(
+  urls: SitemapUrl[],
+  locales: string[],
+  siteUrl: string
+): SitemapUrl[] {
+  const baseSiteUrl = siteUrl.endsWith('/') ? siteUrl.slice(0, -1) : siteUrl;
+  const expandedUrls: SitemapUrl[] = [];
+
+  for (const url of urls) {
+    // Normalize the path (remove leading slash if present for consistency)
+    let path = url.loc;
+    if (path.startsWith(baseSiteUrl)) {
+      path = path.replace(baseSiteUrl, '');
+    }
+    if (!path.startsWith('/')) {
+      path = '/' + path;
+    }
+
+    // Check if the path already has a locale prefix
+    const hasLocalePrefix = locales.some(
+      (locale) => path === `/${locale}` || path.startsWith(`/${locale}/`)
+    );
+
+    if (hasLocalePrefix) {
+      // URL already has locale prefix, just normalize it
+      expandedUrls.push({
+        ...url,
+        loc: normalizeUrl(path, siteUrl),
+      });
+    } else {
+      // Create a URL for each locale
+      for (const locale of locales) {
+        const localePath = path === '/' ? `/${locale}` : `/${locale}${path}`;
+        expandedUrls.push({
+          ...url,
+          loc: `${baseSiteUrl}${localePath}`,
+        });
+      }
+    }
+  }
+
+  return expandedUrls;
+}
+

package/src/sitemap/types.ts

@@ -4,11 +4,20 @@
 
 import type { ChangeFreq, SitemapUrl } from '../types';
 
+export interface SitemapI18nOptions {
+  /** Supported locales (e.g., ['en', 'ru', 'ko']) */
+  locales: string[];
+  /** Default locale for x-default hreflang */
+  defaultLocale: string;
+}
+
 export interface SitemapGeneratorOptions {
   siteUrl: string;
   staticPages?: SitemapUrl[];
   dynamicPages?: (() => Promise<SitemapUrl[]>) | SitemapUrl[];
   cacheControl?: string;
+  /** i18n configuration for hreflang support */
+  i18n?: SitemapI18nOptions;
 }
 
 export interface SitemapRoute {