analogjs · brandonroberts · Mar 18, 2025 · Mar 17, 2025
diff --git a/apps/blog-app/vite.config.ts b/apps/blog-app/vite.config.ts
@@ -3,6 +3,7 @@
 import analog, { type PrerenderContentFile } from '@analogjs/platform';
 import { nxViteTsPaths } from '@nx/vite/plugins/nx-tsconfig-paths.plugin';
 import { defineConfig } from 'vite';
+import fs from 'node:fs';
 
 // Only run in Netlify CI
 let base = process.env['URL'] || 'http://localhost:3000';
@@ -52,7 +53,14 @@ export default defineConfig(() => {
               '/blog',
               '/about',
               '/api/rss.xml',
-              '/blog/2022-12-27-my-first-post',
+              {
+                route: '/blog/2022-12-27-my-first-post',
+                sitemap: () => {
+                  return {
+                    lastmod: '2022-12-27',
+                  };
+                },
+              },
               '/blog/my-second-post',
               '/about-me',
               '/about-you',
@@ -64,6 +72,12 @@ export default defineConfig(() => {
                   }
                   return `/archived/${file.attributes.slug || file.name}`;
                 },
+                sitemap: (file: PrerenderContentFile) => {
+                  console.log(file.name);
+                  return {
+                    changefreq: 'never',
+                  };
+                },
               },
             ];
           },

diff --git a/apps/docs-app/docs/features/server/static-site-generation.md b/apps/docs-app/docs/features/server/static-site-generation.md
@@ -76,6 +76,8 @@ export default defineConfig(({ mode }) => ({
 
 To only prerender the static pages, use the `static: true` flag.
 
+> The `ssr` flag must still be set to `true` for prerendering static pages.
+
 ```ts
 import { defineConfig } from 'vite';
 import analog from '@analogjs/platform';
@@ -109,8 +111,7 @@ The static pages can be deployed from the `dist/analog/public` directory.
 
 ### Sitemap Generation
 
-Analog also supports automatic sitemap generation. Analog generates a sitemap in the `dist/analog/public`
-directory when running a build if a sitemap configuration is provided.
+Analog also supports automatic sitemap generation. Analog generates a sitemap in the `dist/analog/public` directory when running a build if a sitemap configuration is provided.
 
 ```ts
 import { defineConfig } from 'vite';
@@ -131,8 +132,51 @@ export default defineConfig(({ mode }) => ({
 }));
 ```
 
-As long as routes are provided, Analog generates a `sitemap.xml` file containing a
-mapping of the pages' `<loc>` and `<lastmod>` properties.
+To customize the sitemap definition, use the `sitemap` callback function to customize the `lastmod`, `changefreq`, and `priority` fields.
+
+```ts
+import { defineConfig } from 'vite';
+import analog from '@analogjs/platform';
+import fs from 'node:fs';
+
+// https://vitejs.dev/config/
+export default defineConfig(({ mode }) => ({
+  plugins: [
+    analog({
+      prerender: {
+        sitemap: {
+          host: 'https://analogjs.org/',
+        },
+        routes: async () => [
+          '/',
+          '/blog',
+          {
+            route: '/blog/2022-12-27-my-first-post',
+            sitemap: {
+              lastmod: '2022-12-27',
+            },
+          },
+          {
+            contentDir: '/src/content/archived',
+            transform: (file: PrerenderContentFile) => {
+              return `/archived/${file.attributes.slug || file.name}`;
+            },
+            sitemap: (file: PrerenderContentFile) => {
+              return {
+                lastmod: 'read last modified date for content file',
+                changefreq: 'never',
+              };
+            },
+          },
+        ],
+      },
+    }),
+  ],
+}));
+```
+
+As long as prerender routes are provided, Analog generates a `sitemap.xml` file containing a
+mapping of the pages' `<loc>`, `<lastmod>`, `<changefreq>`, and `<priority>` properties.
 
 ```xml
 <?xml version="1.0" encoding="UTF-8"?>
@@ -143,8 +187,13 @@ mapping of the pages' `<loc>` and `<lastmod>` properties.
         <lastmod>2023-07-01</lastmod>
     </url>
     <url>
-        <loc>https://analogjs.org/blog</loc>
-        <lastmod>2023-07-01</lastmod>
+        <loc>https://analogjs.org/blog/2022-12-27-my-first-post</loc>
+        <lastmod>2022-12-27</lastmod>
+    </url>
+    <url>
+        <loc>https://analogjs.org/blog/archived/hello-world</loc>
+        <lastmod>2022-12-01</lastmod>
+        <changefreq>never</changefreq>
     </url>
 </urlset...>
 ```

diff --git a/packages/platform/src/lib/options.ts b/packages/platform/src/lib/options.ts
@@ -1,6 +1,11 @@
 import type { PluginOptions } from '@analogjs/vite-plugin-angular';
 import type { NitroConfig, PrerenderRoute } from 'nitropack';
-import type { SitemapConfig } from '@analogjs/vite-plugin-nitro';
+import type {
+  SitemapConfig,
+  PrerenderContentDir,
+  PrerenderContentFile,
+  PrerenderRouteConfig,
+} from '@analogjs/vite-plugin-nitro';
 
 import { ContentPluginOptions } from './content-plugin.js';
 
@@ -24,8 +29,10 @@ export interface PrerenderOptions {
    * List of routes to prerender resolved statically or dynamically.
    */
   routes?:
-    | (string | PrerenderContentDir)[]
-    | (() => Promise<(string | PrerenderContentDir | undefined)[]>);
+    | (string | PrerenderContentDir | PrerenderRouteConfig)[]
+    | (() => Promise<
+        (string | PrerenderContentDir | PrerenderRouteConfig | undefined)[]
+      >);
   sitemap?: SitemapConfig;
   /** List of functions that run for each route after pre-rendering is complete. */
   postRenderingHooks?: ((routes: PrerenderRoute) => Promise<void>)[];
@@ -81,31 +88,4 @@ export interface Options {
   disableTypeChecking?: boolean;
 }
 
-export interface PrerenderContentDir {
-  /**
-   * The directory or glob pattern where the files should be grabbed from.
-   * @example `/src/contents/blog`
-   */
-  contentDir: string;
-  /**
-   * Transform the matching content files path into a route.
-   * The function is called for each matching content file within the specified contentDir.
-   * @param file information of the matching file (`path`, `name`, `extension`, `attributes`)
-   * @returns a string with the route should be returned (e. g. `/blog/<slug>`) or the value `false`, when the route should not be prerendered.
-   */
-  transform: (file: PrerenderContentFile) => string | false;
-}
-
-/**
- * @param path the path to the content file
- * @param name the basename of the matching content file without the file extension
- * @param extension the file extension
- * @param attributes the frontmatter attributes extracted from the frontmatter section of the file
- * @returns a string with the route should be returned (e. g. `/blog/<slug>`) or the value `false`, when the route should not be prerendered.
- */
-export interface PrerenderContentFile {
-  path: string;
-  attributes: Record<string, any>;
-  name: string;
-  extension: string;
-}
+export { PrerenderContentDir, PrerenderContentFile };
diff --git a/packages/vite-plugin-nitro/src/index.ts b/packages/vite-plugin-nitro/src/index.ts
@@ -1,5 +1,11 @@
 import { nitro } from './lib/vite-plugin-nitro.js';
-export { Options, SitemapConfig } from './lib/options.js';
+export {
+  Options,
+  SitemapConfig,
+  PrerenderRouteConfig,
+  PrerenderContentDir,
+  PrerenderContentFile,
+} from './lib/options.js';
 
 declare module 'nitropack' {
   interface NitroRouteConfig {

diff --git a/packages/vite-plugin-nitro/src/lib/build-sitemap.ts b/packages/vite-plugin-nitro/src/lib/build-sitemap.ts
@@ -3,34 +3,60 @@ import { XMLBuilder } from 'xmlbuilder2/lib/interfaces';
 import { create } from 'xmlbuilder2';
 import { UserConfig } from 'vite';
 import { resolve } from 'node:path';
-import { SitemapConfig } from './options';
+import {
+  PrerenderContentFile,
+  PrerenderSitemapConfig,
+  SitemapConfig,
+} from './options';
 
 export type PagesJson = {
   page: string;
   lastMod: string;
+  changefreq?: string;
+  priority?: string;
 };
 
 export async function buildSitemap(
   config: UserConfig,
   sitemapConfig: SitemapConfig,
   routes: (string | undefined)[] | (() => Promise<(string | undefined)[]>),
   outputDir: string,
+  routeSitemaps: Record<
+    string,
+    PrerenderSitemapConfig | (() => PrerenderSitemapConfig) | undefined
+  >,
 ) {
   const routeList: string[] = await optionHasRoutes(routes);
 
   if (routeList.length) {
     const slash = checkSlash(sitemapConfig.host || '');
-    const sitemapData: PagesJson[] = routeList.map((page: string) => ({
-      page: `${sitemapConfig.host}${slash}${page.replace(/^\/+/g, '')}`,
-      lastMod: new Date().toISOString().split('T')[0],
-    }));
+    const sitemapData: PagesJson[] = routeList.map((page: string) => {
+      const url = `${slash}${page.replace(/^\/+/g, '')}`;
+      const config = routeSitemaps[url];
+      const props = typeof config === 'object' ? config : config?.();
+
+      return {
+        page: `${sitemapConfig.host}${url}`,
+        lastMod: props?.lastmod ?? new Date().toISOString().split('T')[0],
+        changefreq: props?.changefreq,
+        priority: props?.priority,
+      };
+    });
 
     const sitemap = createXml('urlset');
 
     for (const item of sitemapData) {
       const page = sitemap.ele('url');
       page.ele('loc').txt(item.page);
       page.ele('lastmod').txt(item.lastMod);
+
+      if (item.changefreq) {
+        page.ele('changefreq').txt(item.changefreq);
+      }
+
+      if (item.priority) {
+        page.ele('priority').txt(item.priority);
+      }
     }
 
     const mapPath = `${resolve(outputDir)}/sitemap.xml`;

diff --git a/packages/vite-plugin-nitro/src/lib/options.ts b/packages/vite-plugin-nitro/src/lib/options.ts
@@ -43,8 +43,10 @@ export interface PrerenderOptions {
    * List of routes to prerender resolved statically or dynamically.
    */
   routes?:
-    | (string | PrerenderContentDir)[]
-    | (() => Promise<(string | PrerenderContentDir | undefined)[]>);
+    | (string | PrerenderContentDir | PrerenderRouteConfig)[]
+    | (() => Promise<
+        (string | PrerenderContentDir | PrerenderRouteConfig | undefined)[]
+      >);
   sitemap?: SitemapConfig;
   /** List of functions that run for each route after pre-rendering is complete. */
   postRenderingHooks?: ((routes: PrerenderRoute) => Promise<void>)[];
@@ -67,6 +69,15 @@ export interface PrerenderContentDir {
    * @returns a string with the route should be returned (e. g. `/blog/<slug>`) or the value `false`, when the route should not be prerendered.
    */
   transform: (file: PrerenderContentFile) => string | false;
+
+  /**
+   * Customize the sitemap definition for the prerendered route
+   *
+   * https://www.sitemaps.org/protocol.html#xmlTagDefinitions
+   */
+  sitemap?:
+    | PrerenderSitemapConfig
+    | ((file: PrerenderContentFile) => PrerenderSitemapConfig);
 }
 
 /**
@@ -82,3 +93,26 @@ export interface PrerenderContentFile {
   name: string;
   extension: string;
 }
+
+export interface PrerenderSitemapConfig {
+  lastmod?: string;
+  changefreq?:
+    | 'always'
+    | 'hourly'
+    | 'daily'
+    | 'weekly'
+    | 'monthly'
+    | 'yearly'
+    | 'never';
+  priority?: string;
+}
+
+export interface PrerenderRouteConfig {
+  route: string;
+  /**
+   * Customize the sitemap definition for the prerendered route
+   *
+   * https://www.sitemaps.org/protocol.html#xmlTagDefinitions
+   */
+  sitemap?: PrerenderSitemapConfig | (() => PrerenderSitemapConfig);
+}