feat: add configuration for sitemap index and multiple sitemaps

fix #6

BREAKING CHANGE: Drop support for Nuxt.js 1.x

Author: NicoPennec

README.md

@@ -1,4 +1,5 @@
 # Sitemap Module
+
 [![npm (scoped with tag)](https://img.shields.io/npm/v/@nuxtjs/sitemap/latest.svg?style=flat-square)](https://npmjs.com/package/@nuxtjs/sitemap)
 [![npm](https://img.shields.io/npm/dt/@nuxtjs/sitemap.svg?style=flat-square)](https://npmjs.com/package/@nuxtjs/sitemap)
 [![CircleCI](https://img.shields.io/circleci/project/github/nuxt-community/sitemap-module.svg?style=flat-square)](https://circleci.com/gh/nuxt-community/sitemap-module)
@@ -13,26 +14,49 @@
 ## Features
 
 - Module based on the awesome **[sitemap.js](https://github.com/ekalinin/sitemap.js) package** ❤️
-- Automatically add the static routes to the sitemap
+- Create **sitemap** or **sitemap index**
+- Automatically add the static routes to each sitemap
 - Works with **all modes** (universal, spa, generate)
-- For **Nuxt 1.x** and higher
+- For **Nuxt 2.x** and higher
+
+---
+
+## Table of Contents
+
+- [Installation](#installation)
+- [Usage](#usage)
+- [Sitemap Configuration](#sitemap-configuration)
+- [Sitemap Index Configuration](#sitemap-index-configuration)
+- [Routes Declaration](#routes-declaration)
+
+## Installation
+
+> npm install @nuxtjs/sitemap --save
+
+or
 
-## Setup
+> yarn add @nuxtjs/sitemap
 
-- Add the `@nuxtjs/sitemap` dependency with `yarn` or `npm` to your project.
+## Usage
 
-- Add `@nuxtjs/sitemap` to the `modules` section of `nuxt.config.js`:
+- Add `@nuxtjs/sitemap` to the `modules` section of your `nuxt.config.js` file:
 
 ```js
   modules: [
     '@nuxtjs/sitemap'
   ]
 ```
-> **notice:** If you use other modules (eg. `nuxt-i18n`), always declare the sitemap module at end of array (eg. `modules: ['nuxt-i18n', '@nuxtjs/sitemap']`)
 
-- Configure it:
+> **notice:**  
+> If you use other modules (eg. `nuxt-i18n`), always declare the sitemap module at end of array  
+> eg. `modules: ['nuxt-i18n', '@nuxtjs/sitemap']`
+
+- Add a custom configuration with the `sitemap` property.
+
+You can set a single item of [sitemap](#sitemap-configuration) or [sitemap index](#sitemap-index-configuration) or an array of item:
 
 ```js
+// Setup a simple sitemap.xml
 {
   modules: [
     '@nuxtjs/sitemap'
@@ -56,41 +80,96 @@
   }
 ```
 
-## Configuration
+```js
+// Setup a sitemap index and its linked sitemaps
+{
+  modules: [
+    '@nuxtjs/sitemap'
+  ],
+  sitemap: {
+    path: '/sitemapindex.xml',
+    hostname: 'https://example.com',
+    lastmod: '2017-06-30',
+    sitemaps: [
+      {
+        path: '/sitemap-foo.xml',
+        routes: ['foo/1', 'foo/2'],
+        gzip: true
+      }, {
+        path: '/folder/sitemap-bar.xml',
+        routes: ['bar/1', 'bar/2'],
+        exclude: ['/**']
+      }
+    ]
+  }
+```
+
+```js
+// Setup several sitemaps
+{
+  modules: [
+    '@nuxtjs/sitemap'
+  ],
+  sitemap: [
+    {
+      path: '/sitemap-products.xml',
+      routes: [
+        // array of URL
+      ]
+    }, {
+      path: '/sitemap-news.xml',
+      routes: () => // promise or function
+    }, {
+      path: '/sitemapindex.xml',
+      sitemaps: [{
+        // array of Sitemap configuration
+      }]
+    }
+  }
+}
+```
+
+## Sitemap Options
+
+### `routes` - array or promise function
 
-### `routes`
 - Default: `[]` or [`generate.routes`](https://nuxtjs.org/api/configuration-generate#routes) value from your `nuxt.config.js`
 
 The `routes` parameter follows the same way than the `generate` [configuration](https://nuxtjs.org/api/configuration-generate).
-   
-See as well the [routes](#routes-1) examples below.
 
-### `path` (optional)
+See as well the [routes declaration](#routes-declaration) examples below.
+
+### `path` (optional) - string
+
 - Default: `/sitemap.xml`
 
 The URL path of the generated sitemap.
 
-### `hostname` (optional)
-- Default: 
+### `hostname` (optional) - string
+
+- Default:
   1. `sitemap.hostname` value from your `nuxt.config.js`
   2. [`build.publicPath`](https://nuxtjs.org/api/configuration-build/#publicpath) value from your `nuxt.config.js`
   3. [`os.hostname()`](https://nodejs.org/api/os.html#os_os_hostname) for **generate** or **spa** mode, or dynamically based on request URL (`headers.host`) for **universal** mode
 
 This value is **mandatory** for generation sitemap file, and you should explicitly provide it for **generate** or **spa** mode.
 
-### `cacheTime` (optional)
+### `cacheTime` (optional) - number
+
 - Default: `1000 * 60 * 15` (15 Minutes)
 
-Defines how frequently should sitemap **routes** being updated.
+Defines how frequently should sitemap **routes** being updated (value in milliseconds).
+
+Please note that after each invalidation, `routes` will be evaluated again. (See [routes declaration](#routes-declaration) section)
 
-Please note that after each invalidation, `routes` will be evaluated again. (See [routes](#routes-1) section)
+### `exclude` (optional) - string array
 
-### `exclude` (optional)
 - Default: `[]`
 
 The `exclude` parameter is an array of [glob patterns](https://github.com/isaacs/minimatch#features) to exclude static routes from the generated sitemap.
 
-### `filter` (optional)
+### `filter` (optional) - function
+
 - Default: `undefined`
 
 If `filter` option is set as a function, all routes will be filtered through it.
@@ -125,12 +204,14 @@ Examples:
 }
 ```
 
-### `gzip` (optional)
+### `gzip` (optional) - boolean
+
 - Default: `false`
 
 Enable the creation of the `.xml.gz` sitemap compressed with gzip.
 
-### `xmlNs` (optional)
+### `xmlNs` (optional) - string
+
 - Default: `undefined`
 
 Set the XML namespaces by override all default `xmlns` attributes in `<urlset>` element.
@@ -145,19 +226,22 @@ Set the XML namespaces by override all default `xmlns` attributes in `<urlset>`
 }
 ```
 
-### `xslUrl` (optional)
+### `xslUrl` (optional) - string
+
 - Default: `undefined`
 
 The URL path of the XSL file to style the sitemap.
 
-### `trailingSlash` (optional)
+### `trailingSlash` (optional) - boolean
+
 - Default: `false`
 
 Add a trailing slash to each route URL (eg. `/page/1` => `/page/1/`)
 
 > **notice:** To avoid [duplicate content](https://support.google.com/webmasters/answer/66359) detection from crawlers, you have to configure an HTTP 301 redirect between the 2 URLs (see [redirect-module](https://github.com/nuxt-community/redirect-module) or [nuxt-trailingslash-module](https://github.com/WilliamDASILVA/nuxt-trailingslash-module)).
 
-### `defaults` (optional)
+### `defaults` (optional) - object
+
 - Default: `{}`
 
 The `defaults` parameter set the default options for all routes.
@@ -179,7 +263,87 @@ The `defaults` parameter set the default options for all routes.
 
 See available options: https://github.com/ekalinin/sitemap.js#usage
 
-## Routes
+## Sitemap Index Configuration
+
+### `path` (optional) - string
+
+- Default: `/sitemapindex.xml`
+
+The URL path of the generated sitemap index.
+
+### `hostname` (optional) - string
+
+Set the `hostname` value to each sitemap linked to its sitemap index.
+
+### `sitemaps` - array of object
+
+- Default: `[]`
+
+Array of [sitemap configuration](#sitemap-configuration]) linked to the sitemap index.
+
+```js
+  // nuxt.config.js
+
+  sitemap: {
+    path: '/sitemapindex.xml',
+    hostname: 'https://example.com',
+    sitemaps: [
+      {
+        path: '/sitemap-foo.xml',
+        // ...
+      }, {
+        path: '/folder/sitemap-bar.xml',
+        // ...
+      }
+    ]
+  }
+```
+
+```xml
+  <!-- generated sitemapindex.xml -->
+
+  <?xml version="1.0" encoding="UTF-8"?>
+  <sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+    <sitemap>
+      <loc>https://example.com/sitemap-foo.xml</loc>
+    </sitemap>
+    <sitemap>
+      <loc>https://example.com/folder/sitemap-bar.xml</loc>
+    </sitemap>
+  </sitemapindex>
+```
+
+See more [examples](#usage) above.
+
+### `gzip` (optional) - boolean
+
+- Default: `false`
+
+Enable the creation of the `.xml.gz` sitemap index compressed with gzip.
+
+### `xmlNs` (optional) - string
+
+- Default: `undefined`
+
+Set the XML namespaces by override all default `xmlns` attributes in `<sitemapindex>` element.
+
+```js
+// nuxt.config.js
+
+{
+  sitemap: {
+    xmlNs: 'xmlns="http://www.sitemaps.org/schemas/sitemap/0.9"'
+  }
+}
+```
+
+### `xslUrl` (optional) - string
+
+- Default: `undefined`
+
+The URL path of the XSL file to style the sitemap index.
+
+## Routes Declaration
 
 By default, the dynamic routes are ignored by the sitemap module.  
 Nuxt cannot automatically provide this type of complex routes.
@@ -198,6 +362,8 @@ If you want the module to add any route with dynamic parameters, you have to set
 
 eg. add routes for `/users/:id` in the configuration:
 
+### From a static list
+
 ```js
 // nuxt.config.js
 
@@ -212,7 +378,7 @@ eg. add routes for `/users/:id` in the configuration:
 }
 ```
 
-### Function which returns a Promise
+### From a function which returns a Promise
 
 ```js
 // nuxt.config.js
@@ -227,35 +393,12 @@ const axios = require('axios')
     }
   }
 }
-```
-
-### Function with a callback
-
-**This feature is deprecated**. Use a promise-based approach instead.
-
-```js
-// nuxt.config.js
-
-const axios = require('axios')
-
-{
-  sitemap: {
-    routes (callback) {
-      axios.get('https://jsonplaceholder.typicode.com/users')
-      .then(res => {
-        let routes = res.data.map(user => '/users/' + user.username)
-        callback(null, routes)
-      })
-      .catch(callback)
-    }
-  }
-}
-```
 
 ## License
 
 [MIT License](./LICENSE)
 
 ### Contributors
-- [Nicolas PENNEC](https://github.com/NicoPennec)
+
+- [Nicolas Pennec](https://github.com/NicoPennec)
 - [Pooya Parsa](https://github.com/pi0)

lib/builder.js

@@ -1,4 +1,5 @@
 const { hostname } = require('os')
+const { URL } = require('url')
 const { promisify } = require('util')
 
 const isHTTPS = require('is-https')
@@ -7,18 +8,27 @@ const sm = require('sitemap')
 /**
  * Initialize a fresh sitemap instance
  *
- * @param {Object} options
- * @param {Array} routes
- * @param {Request} req
+ * @param   {Object}  options
+ * @param   {Array}   routes
+ * @param   {Request} req
  * @returns {Sitemap} sitemap builder
  */
 function createSitemap(options, routes, req = null) {
   const sitemapConfig = {}
 
+  // Set cacheTime
+  sitemapConfig.cacheTime = options.cacheTime || 0
+
   // Set sitemap hostname
-  sitemapConfig.hostname =
-    options.hostname || (req && `${isHTTPS(req) ? 'https' : 'http'}://${req.headers.host}`) || `http://${hostname()}`
+  sitemapConfig.hostname = getHostname(options, req)
+
+  // Set XML namespaces
+  sitemapConfig.xmlNs = options.xmlNs
+
+  // Set XSL url
+  sitemapConfig.xslUrl = options.xslUrl
 
+  // Set default values to each route
   routes = routes.map(route => ({ ...options.defaults, ...route }))
 
   // Add a trailing slash to each route URL
@@ -32,28 +42,64 @@ function createSitemap(options, routes, req = null) {
   // Enable filter function for each declared route
   if (typeof options.filter === 'function') {
     routes = options.filter({
-      routes,
-      options: { ...options, ...sitemapConfig }
+      options: { ...sitemapConfig },
+      routes
     })
   }
 
   // Set urls and ensure they are unique
   sitemapConfig.urls = [...new Set(routes)]
 
-  // Set cacheTime
-  sitemapConfig.cacheTime = options.cacheTime || 0
+  // Create promisified instance and return
+  const sitemap = sm.createSitemap(sitemapConfig)
+  sitemap.toXML = promisify(sitemap.toXML)
+
+  return sitemap
+}
+
+/**
+ * Initialize a fresh sitemapindex instance
+ *
+ * @param   {Object}  options
+ * @param   {Request} req
+ * @returns {string}
+ */
+function createSitemapIndex(options, req = null) {
+  const sitemapIndexConfig = {}
+
+  // Set urls
+  const defaultHostname = getHostname(options, req)
+  sitemapIndexConfig.urls = options.sitemaps.map(options => {
+    const path = options.gzip ? `${options.path}.gz` : options.path
+    const hostname = options.hostname || defaultHostname
+    const url = new URL(path, hostname)
+    return url.href
+  })
+
+  // Set lastmod for each sitemap
+  sitemapIndexConfig.lastmod = options.lastmod
 
   // Set XML namespaces
-  sitemapConfig.xmlNs = options.xmlNs
+  sitemapIndexConfig.xmlNs = options.xmlNs
 
   // Set XSL url
-  sitemapConfig.xslUrl = options.xslUrl
+  sitemapIndexConfig.xslUrl = options.xslUrl
 
-  // Create promisified instance and return
-  const sitemap = sm.createSitemap(sitemapConfig)
-  sitemap.toXML = promisify(sitemap.toXML)
+  // Create a sitemapindex
+  return sm.buildSitemapIndex(sitemapIndexConfig)
+}
 
-  return sitemap
+/**
+ * Determine the current hostname
+ *
+ * @param   {Object}  options
+ * @param   {Request} req
+ * @returns {string}
+ */
+function getHostname(options, req) {
+  return (
+    options.hostname || (req && `${isHTTPS(req) ? 'https' : 'http'}://${req.headers.host}`) || `http://${hostname()}`
+  )
 }
 
-module.exports = { createSitemap }
+module.exports = { createSitemap, createSitemapIndex }

lib/cache.js

@@ -4,18 +4,18 @@ const AsyncCache = require('async-cache')
 const unionBy = require('lodash.unionby')
 
 /**
- * Initialize a AsyncCache instance for routes
+ * Initialize a cache instance for sitemap routes
  *
- * @param {string[]} staticRoutes
- * @param {Object} options
+ * @param   {Object} globalCache
+ * @param   {Object} options
  * @returns {AsyncCache.Cache<any>} Cache instance
  */
-function createCache(staticRoutes, options) {
+function createRoutesCache(globalCache, options) {
   const cache = new AsyncCache({
     maxAge: options.cacheTime,
     load(_, callback) {
       promisifyRoute(options.routes)
-        .then(routes => routesUnion(staticRoutes, routes))
+        .then(routes => joinRoutes(globalCache.staticRoutes ? globalCache.staticRoutes() : [], routes))
         .then(routes => {
           callback(null, routes)
         })
@@ -31,6 +31,7 @@ function createCache(staticRoutes, options) {
 }
 
 /* istanbul ignore next */
+/* eslint-disable */
 
 /**
  * Promisify the `options.routes` option
@@ -62,30 +63,31 @@ function promisifyRoute(fn) {
   }
   return promise
 }
+/* eslint-enable */
 
 /**
- * Join static and options-defined routes into single array
+ * Join static and dynamic routes into a single list
  *
- * @param {string[]} staticRoutes
- * @param {Array} optionsRoutes
+ * @param   {Array} staticRoutes
+ * @param   {Array} dynamicRoutes
  * @returns {Array} List of routes
  */
-function routesUnion(staticRoutes, optionsRoutes) {
-  // Make sure any routes passed as strings are converted to objects with url properties
-  staticRoutes = staticRoutes.map(ensureRouteIsObject)
-  optionsRoutes = optionsRoutes.map(ensureRouteIsObject)
-  // Add static routes to options routes, discarding any defined in options
-  return unionBy(optionsRoutes, staticRoutes, 'url')
+function joinRoutes(staticRoutes, dynamicRoutes) {
+  // Validate routes
+  staticRoutes = staticRoutes.map(ensureIsValidRoute)
+  dynamicRoutes = dynamicRoutes.map(ensureIsValidRoute)
+  // Join sitemap routes by URL
+  return unionBy(dynamicRoutes, staticRoutes, 'url')
 }
 
 /**
- * Make sure a passed route is an object
+ * Make sure a route is an object with "url" property
  *
- * @param {Object | string} route Route Object or String value
+ * @param   {Object | string} route Route Object or Payload Object or String value
  * @returns {Object} A valid route object
  */
-function ensureRouteIsObject(route) {
-  return typeof route === 'object' ? route : { url: route }
+function ensureIsValidRoute(route) {
+  return typeof route === 'object' ? (route.route ? { url: route.route } : route) : { url: route }
 }
 
-module.exports = { createCache }
+module.exports = { createRoutesCache }

lib/generator.js

@@ -1,46 +1,106 @@
 const path = require('path')
+const { gzipSync } = require('zlib')
 
 const consola = require('consola')
 const fs = require('fs-extra')
 
-const { createSitemap } = require('./builder.js')
+const { createSitemap, createSitemapIndex } = require('./builder.js')
+const { createRoutesCache } = require('./cache.js')
+const { setDefaultSitemapOptions, setDefaultSitemapIndexOptions } = require('./options.js')
+const { excludeRoutes } = require('./routes.js')
 
 /**
- * Generating sitemap
+ * Generate a static file for each sitemap or sitemapindex
  *
  * @param {Object} options
- * @param {Object} cache
- * @param {Nuxt} nuxtInstance
+ * @param {Object} globalCache
+ * @param {Nuxt}   nuxtInstance
  */
-async function generateSitemap(options, cache, nuxtInstance) {
+async function generateSitemaps(options, globalCache, nuxtInstance) {
+  const isSitemapIndex = options && options.sitemaps && Array.isArray(options.sitemaps) && options.sitemaps.length > 0
+
+  if (isSitemapIndex) {
+    await generateSitemapIndex(options, globalCache, nuxtInstance)
+  } else {
+    await generateSitemap(options, globalCache, nuxtInstance)
+  }
+}
+
+/**
+ * Generate a sitemap file
+ *
+ * @param {Object} options
+ * @param {Object} globalCache
+ * @param {Nuxt}   nuxtInstance
+ */
+async function generateSitemap(options, globalCache, nuxtInstance) {
   consola.info('Generating sitemap')
 
+  // Init options
+  options = setDefaultSitemapOptions(options, nuxtInstance)
+
+  // Init cache
+  const cache = {}
+  cache.staticRoutes = () => excludeRoutes(options.exclude, globalCache.staticRoutes)
+  cache.routes = createRoutesCache(cache, options)
+
   // Generate sitemap.xml
-  const routes = await cache.sitemap.get('routes')
+  const routes = await cache.routes.get('routes')
   const sitemap = await createSitemap(options, routes)
   const xml = await sitemap.toXML()
-  const xmlGeneratePath = path.join(nuxtInstance.options.generate.dir, options.path)
-  fs.outputFileSync(xmlGeneratePath, xml)
-  consola.success('Generated', getPathname(nuxtInstance.options.generate.dir, xmlGeneratePath))
+  const xmlFilePath = path.join(nuxtInstance.options.generate.dir, options.path)
+  fs.outputFileSync(xmlFilePath, xml)
+  consola.success('Generated', getPathname(nuxtInstance.options.generate.dir, xmlFilePath))
 
   // Generate sitemap.xml.gz
   if (options.gzip) {
     const gzip = await sitemap.toGzip()
-    const gzipGeneratePath = path.join(nuxtInstance.options.generate.dir, options.pathGzip)
-    fs.outputFileSync(gzipGeneratePath, gzip)
-    consola.success('Generated', getPathname(nuxtInstance.options.generate.dir, gzipGeneratePath))
+    const gzipFilePath = path.join(nuxtInstance.options.generate.dir, options.pathGzip)
+    fs.outputFileSync(gzipFilePath, gzip)
+    consola.success('Generated', getPathname(nuxtInstance.options.generate.dir, gzipFilePath))
+  }
+}
+
+/**
+ * Generate a sitemapindex file
+ *
+ * @param {Object} options
+ * @param {Object} globalCache
+ * @param {Nuxt}   nuxtInstance
+ */
+async function generateSitemapIndex(options, globalCache, nuxtInstance) {
+  consola.info('Generating sitemapindex')
+
+  // Init options
+  options = setDefaultSitemapIndexOptions(options)
+
+  // Generate sitemapindex.xml
+  const xml = createSitemapIndex(options)
+  const xmlFilePath = path.join(nuxtInstance.options.generate.dir, options.path)
+  fs.outputFileSync(xmlFilePath, xml)
+  consola.success('Generated', getPathname(nuxtInstance.options.generate.dir, xmlFilePath))
+
+  // Generate sitemapindex.xml.gz
+  if (options.gzip) {
+    const gzip = gzipSync(xml)
+    const gzipFilePath = path.join(nuxtInstance.options.generate.dir, options.pathGzip)
+    fs.outputFileSync(gzipFilePath, gzip)
+    consola.success('Generated', getPathname(nuxtInstance.options.generate.dir, gzipFilePath))
   }
+
+  // Generate linked sitemaps
+  await Promise.all(options.sitemaps.map(sitemapOptions => generateSitemaps(sitemapOptions, globalCache, nuxtInstance)))
 }
 
 /**
  * Convert a file path to a URL pathname
  *
- * @param {string} dirPath
- * @param {string} filePath
- * @returns {string} URL pathname
+ * @param   {string} dirPath
+ * @param   {string} filePath
+ * @returns {string}
  */
 function getPathname(dirPath, filePath) {
   return [, ...path.relative(dirPath, filePath).split(path.sep)].join('/')
 }
 
-module.exports = { generateSitemap }
+module.exports = { generateSitemaps, generateSitemap, generateSitemapIndex }

lib/middleware.js

@@ -1,19 +1,67 @@
-const { createSitemap } = require('./builder.js')
+const { gzipSync } = require('zlib')
+
+const consola = require('consola')
+
+const { createSitemap, createSitemapIndex } = require('./builder.js')
+const { createRoutesCache } = require('./cache.js')
+const { setDefaultSitemapOptions, setDefaultSitemapIndexOptions } = require('./options.js')
+const { excludeRoutes } = require('./routes.js')
+
+/**
+ * Register a middleware for each sitemap or sitemapindex
+ *
+ * @param {Object} options
+ * @param {Object} globalCache
+ * @param {Nuxt}   nuxtInstance
+ * @param {number} depth
+ */
+function registerSitemaps(options, globalCache, nuxtInstance, depth = 0) {
+  if (depth > 1) {
+    // see https://webmasters.stackexchange.com/questions/18243/can-a-sitemap-index-contain-other-sitemap-indexes
+    /* istanbul ignore next */
+    consola.warn("A sitemap index file can't list other sitemap index files, but only sitemap files")
+  }
+
+  const isSitemapIndex = options && options.sitemaps && Array.isArray(options.sitemaps) && options.sitemaps.length > 0
+
+  if (isSitemapIndex) {
+    registerSitemapIndex(options, globalCache, nuxtInstance, depth)
+  } else {
+    registerSitemap(options, globalCache, nuxtInstance)
+  }
+}
 
 /**
  * Register a middleware to serve a sitemap
  *
  * @param {Object} options
- * @param {Object} cache
- * @param {Nuxt} nuxtInstance
+ * @param {Object} globalCache
+ * @param {Nuxt}   nuxtInstance
  */
-function registerSitemap(options, cache, nuxtInstance) {
+function registerSitemap(options, globalCache, nuxtInstance) {
+  // Init options
+  options = setDefaultSitemapOptions(options, nuxtInstance)
+
+  // Init cache
+  const cache = {}
+  cache.staticRoutes = () => excludeRoutes(options.exclude, globalCache.staticRoutes)
+  cache.routes = createRoutesCache(cache, options)
+
+  // On run cmd "start" or "generate [--no-build]"
+  if (globalCache.staticRoutes) {
+    // On server ready
+    nuxtInstance.nuxt.hook('listen', () => {
+      // Hydrate cache
+      cache.routes.get('routes')
+    })
+  }
+
   if (options.gzip) {
     // Add server middleware for sitemap.xml.gz
     nuxtInstance.addServerMiddleware({
       path: options.pathGzip,
       handler(req, res, next) {
-        cache.sitemap
+        cache.routes
           .get('routes')
           .then(routes => createSitemap(options, routes, req))
           .then(sitemap => sitemap.toGzip())
@@ -34,7 +82,7 @@ function registerSitemap(options, cache, nuxtInstance) {
   nuxtInstance.addServerMiddleware({
     path: options.path,
     handler(req, res, next) {
-      cache.sitemap
+      cache.routes
         .get('routes')
         .then(routes => createSitemap(options, routes, req))
         .then(sitemap => sitemap.toXML())
@@ -50,4 +98,44 @@ function registerSitemap(options, cache, nuxtInstance) {
   })
 }
 
-module.exports = { registerSitemap }
+/**
+ * Register a middleware to serve a sitemapindex
+ *
+ * @param {Object} options
+ * @param {Object} globalCache
+ * @param {Nuxt}   nuxtInstance
+ * @param {number} depth
+ */
+function registerSitemapIndex(options, globalCache, nuxtInstance, depth = 0) {
+  // Init options
+  options = setDefaultSitemapIndexOptions(options)
+
+  if (options.gzip) {
+    // Add server middleware for sitemapindex.xml.gz
+    nuxtInstance.addServerMiddleware({
+      path: options.pathGzip,
+      handler(req, res, next) {
+        const sitemapIndex = createSitemapIndex(options, req)
+        const gzip = gzipSync(sitemapIndex)
+        res.setHeader('Content-Type', 'application/x-gzip')
+        res.setHeader('Content-Encoding', 'gzip')
+        res.end(gzip)
+      }
+    })
+  }
+
+  // Add server middleware for sitemapindex.xml
+  nuxtInstance.addServerMiddleware({
+    path: options.path,
+    handler(req, res, next) {
+      const sitemapIndex = createSitemapIndex(options, req)
+      res.setHeader('Content-Type', 'application/xml')
+      res.end(sitemapIndex)
+    }
+  })
+
+  // Register linked sitemaps
+  options.sitemaps.forEach(sitemapOptions => registerSitemaps(sitemapOptions, globalCache, nuxtInstance, depth + 1))
+}
+
+module.exports = { registerSitemaps, registerSitemap, registerSitemapIndex }

lib/module.js

@@ -2,89 +2,48 @@ const path = require('path')
 
 const consola = require('consola')
 const fs = require('fs-extra')
-const { Minimatch } = require('minimatch')
 
-const { createCache } = require('./cache.js')
-const { generateSitemap } = require('./generator.js')
-const { registerSitemap } = require('./middleware.js')
+const { generateSitemaps } = require('./generator.js')
+const { registerSitemaps } = require('./middleware.js')
 const { getStaticRoutes } = require('./routes.js')
 
-const defaultPublicPath = '/_nuxt/'
-
 module.exports = function module(moduleOptions) {
-  const defaults = {
-    path: '/sitemap.xml',
-    hostname: this.options.build.publicPath !== defaultPublicPath ? this.options.build.publicPath : undefined,
-    exclude: [],
-    routes: this.options.generate.routes || [],
-    cacheTime: 1000 * 60 * 15,
-    filter: undefined,
-    gzip: false,
-    xmlNs: undefined,
-    xslUrl: undefined,
-    trailingSlash: false,
-    defaults: {}
-  }
-
-  const options = {
-    ...defaults,
-    ...this.options.sitemap,
-    ...moduleOptions
-  }
+  const nuxtInstance = this
 
-  options.pathGzip = options.gzip ? `${options.path}.gz` : options.path
+  // Init options
+  let options = nuxtInstance.options.sitemap || moduleOptions
+  options = Array.isArray(options) ? options : [options]
 
-  // sitemap-routes.json is written to dist dir on "build" mode
-  const jsonStaticRoutesPath = !this.options.dev
-    ? path.resolve(this.options.buildDir, path.join('dist', 'sitemap-routes.json'))
+  // Init cache
+  // a file "sitemap-routes.json" is written to "dist" dir on "build" mode
+  const jsonStaticRoutesPath = !nuxtInstance.options.dev
+    ? path.resolve(nuxtInstance.options.buildDir, path.join('dist', 'sitemap-routes.json'))
     : null
-
   const staticRoutes = fs.readJsonSync(jsonStaticRoutesPath, { throws: false })
-  const cache = {}
-
-  // On run cmd "start" or "generate [--no-build]"
-  if (staticRoutes) {
-    // Create a cache for routes
-    cache.sitemap = createCache(staticRoutes, options)
-
-    // On server ready, hydrate cache
-    this.nuxt.hook('listen', () => {
-      cache.sitemap.get('routes')
-    })
-  }
+  const globalCache = { staticRoutes }
 
-  // On extend routes
-  this.extendRoutes(routes => {
-    let staticRoutes = getStaticRoutes(routes)
+  // Init static routes
+  nuxtInstance.extendRoutes(routes => {
+    // Create a cache for static routes
+    globalCache.staticRoutes = getStaticRoutes(routes)
 
-    // Exclude routes
-    options.exclude.forEach(pattern => {
-      const minimatch = new Minimatch(pattern)
-      minimatch.negate = true
-      staticRoutes = staticRoutes.filter(route => minimatch.match(route))
-    })
-
-    // Create a cache for routes
-    cache.sitemap = createCache(staticRoutes, options)
-
-    if (!this.options.dev) {
+    // On run cmd "build"
+    if (!nuxtInstance.options.dev) {
       // Save static routes
-      fs.outputJsonSync(jsonStaticRoutesPath, staticRoutes)
+      fs.outputJsonSync(jsonStaticRoutesPath, globalCache.staticRoutes)
     }
   })
 
-  /* istanbul ignore if */
-  if (options.generate) {
-    consola.warn("The option `sitemap.generate` isn't needed anymore")
-  }
-
-  // On "generate" mode, generate a sitemap file in dist dir
-  this.nuxt.hook('generate:done', async () => {
-    await generateSitemap(options, cache, this)
+  // On "generate" mode, generate static files for each sitemap or sitemapindex
+  nuxtInstance.nuxt.hook('generate:done', async () => {
+    consola.info('Generating sitemaps')
+    await Promise.all(options.map(options => generateSitemaps(options, globalCache, nuxtInstance)))
   })
 
-  // On "universal" mode, register a middleware for each sitemap path
-  registerSitemap(options, cache, this)
+  // On "universal" mode, register middlewares for each sitemap or sitemapindex
+  options.forEach(options => {
+    registerSitemaps(options, globalCache, nuxtInstance)
+  })
 }
 
 module.exports.meta = require('../package.json')

lib/options.js

@@ -0,0 +1,91 @@
+const consola = require('consola')
+
+const DEFAULT_NUXT_PUBLIC_PATH = '/_nuxt/'
+
+/**
+ * Set default options for a sitemap config
+ *
+ * @param   {Object} options
+ * @param   {Nuxt}   nuxtInstance
+ * @returns {Object}
+ */
+function setDefaultSitemapOptions(options, nuxtInstance) {
+  const defaults = {
+    path: '/sitemap.xml',
+    hostname:
+      nuxtInstance.options.build.publicPath !== DEFAULT_NUXT_PUBLIC_PATH
+        ? nuxtInstance.options.build.publicPath
+        : undefined,
+    exclude: [],
+    routes: nuxtInstance.options.generate.routes || [],
+    cacheTime: 1000 * 60 * 15,
+    filter: undefined,
+    gzip: false,
+    xmlNs: undefined,
+    xslUrl: undefined,
+    trailingSlash: false,
+    defaults: {}
+  }
+
+  options = {
+    ...defaults,
+    ...options
+  }
+
+  /* istanbul ignore if */
+  if (options.generate) {
+    consola.warn('The "generate" option isn\'t needed anymore')
+  }
+
+  /* istanbul ignore if */
+  if (!options.path) {
+    consola.warn('The "path" option is either empty or missing for a sitemap')
+  }
+
+  options.pathGzip = options.gzip ? `${options.path}.gz` : options.path
+
+  return options
+}
+
+/**
+ * Set default options for a sitemapindex config
+ *
+ * @param   {Object} options
+ * @returns {Object}
+ */
+function setDefaultSitemapIndexOptions(options) {
+  const defaults = {
+    path: '/sitemapindex.xml',
+    hostname: undefined,
+    sitemaps: [],
+    gzip: false,
+    xmlNs: undefined,
+    xslUrl: undefined
+  }
+
+  options = {
+    ...defaults,
+    ...options
+  }
+
+  /* istanbul ignore if */
+  if (options.generate) {
+    consola.warn("The option `generate` isn't needed anymore")
+  }
+
+  /* istanbul ignore if */
+  if (!options.path) {
+    consola.warn('The "path" option is either empty or missing for a sitemap index')
+  }
+
+  // set cascading hostname
+  options.sitemaps.forEach(sitemapOptions => {
+    sitemapOptions.hostname = sitemapOptions.hostname || options.hostname
+  })
+
+  options.pathGzip = options.gzip ? `${options.path}.gz` : options.path
+
+  return options
+}
+
+module.exports = { setDefaultSitemapOptions, setDefaultSitemapIndexOptions }

lib/routes.js

@@ -1,7 +1,25 @@
+const { Minimatch } = require('minimatch')
+
+/**
+ * Exclude routes by glob patterns
+ *
+ * @param   {string[]} patterns
+ * @param   {string[]} routes
+ * @returns {string[]}
+ */
+function excludeRoutes(patterns, routes) {
+  patterns.forEach(pattern => {
+    const minimatch = new Minimatch(pattern)
+    minimatch.negate = true
+    routes = routes.filter(route => minimatch.match(route))
+  })
+  return routes
+}
+
 /**
- * Get list of static routes from Nuxt router
+ * Get static routes from Nuxt router and ignore dynamic routes
  *
- * @param {Object} router
+ * @param   {Object} router
  * @returns {string[]}
  */
 function getStaticRoutes(router) {
@@ -12,9 +30,9 @@ function getStaticRoutes(router) {
 /**
  * Recursively flatten all routes and their child-routes
  *
- * @param {Object} router
- * @param {string} path
- * @param {string[]} routes
+ * @param   {Object}   router
+ * @param   {string}   path
+ * @param   {string[]} routes
  * @returns {string[]}
  */
 function flattenRoutes(router, path = '', routes = []) {
@@ -29,4 +47,4 @@ function flattenRoutes(router, path = '', routes = []) {
   return routes
 }
 
-module.exports = { getStaticRoutes }
+module.exports = { excludeRoutes, getStaticRoutes }

package.json

@@ -74,7 +74,7 @@
     "standard-version": "latest"
   },
   "engines": {
-    "node": ">=8.0.0",
+    "node": ">=8.9.0",
     "npm": ">=5.0.0"
   },
   "publishConfig": {

test/__snapshots__/module.test.js.snap

@@ -1,5 +1,25 @@
 // Jest Snapshot v1, https://goo.gl/fbAQLP
 
-exports[`sitemap - generate mode sitemap.xml 1`] = `"<?xml version=\\"1.0\\" encoding=\\"UTF-8\\"?><urlset xmlns=\\"http://www.sitemaps.org/schemas/sitemap/0.9\\" xmlns:news=\\"http://www.google.com/schemas/sitemap-news/0.9\\" xmlns:xhtml=\\"http://www.w3.org/1999/xhtml\\" xmlns:mobile=\\"http://www.google.com/schemas/sitemap-mobile/1.0\\" xmlns:image=\\"http://www.google.com/schemas/sitemap-image/1.1\\" xmlns:video=\\"http://www.google.com/schemas/sitemap-video/1.1\\"><url><loc>https://example.com/child</loc></url><url><loc>https://example.com/exclude</loc></url><url><loc>https://example.com/filtered</loc></url><url><loc>https://example.com/parent/child/subchild</loc></url><url><loc>https://example.com/parent/child</loc></url><url><loc>https://example.com/parent</loc></url><url><loc>https://example.com/sub</loc></url><url><loc>https://example.com/sub/sub</loc></url><url><loc>https://example.com/</loc></url></urlset>"`;
+exports[`sitemap - generate mode sitemap.xml 1`] = `"<?xml version=\\"1.0\\" encoding=\\"UTF-8\\"?><urlset xmlns=\\"http://www.sitemaps.org/schemas/sitemap/0.9\\" xmlns:news=\\"http://www.google.com/schemas/sitemap-news/0.9\\" xmlns:xhtml=\\"http://www.w3.org/1999/xhtml\\" xmlns:mobile=\\"http://www.google.com/schemas/sitemap-mobile/1.0\\" xmlns:image=\\"http://www.google.com/schemas/sitemap-image/1.1\\" xmlns:video=\\"http://www.google.com/schemas/sitemap-video/1.1\\"><url><loc>https://example.com/child</loc></url><url><loc>https://example.com/filtered</loc></url><url><loc>https://example.com/parent/child/subchild</loc></url><url><loc>https://example.com/parent/child</loc></url><url><loc>https://example.com/parent</loc></url><url><loc>https://example.com/sub</loc></url><url><loc>https://example.com/sub/sub</loc></url><url><loc>https://example.com/</loc></url></urlset>"`;
 
 exports[`sitemap - minimal configuration sitemap.xml 1`] = `"<?xml version=\\"1.0\\" encoding=\\"UTF-8\\"?><urlset xmlns=\\"http://www.sitemaps.org/schemas/sitemap/0.9\\" xmlns:news=\\"http://www.google.com/schemas/sitemap-news/0.9\\" xmlns:xhtml=\\"http://www.w3.org/1999/xhtml\\" xmlns:mobile=\\"http://www.google.com/schemas/sitemap-mobile/1.0\\" xmlns:image=\\"http://www.google.com/schemas/sitemap-image/1.1\\" xmlns:video=\\"http://www.google.com/schemas/sitemap-video/1.1\\"><url><loc>https://example.com/child</loc></url><url><loc>https://example.com/exclude</loc></url><url><loc>https://example.com/filtered</loc></url><url><loc>https://example.com/parent/child/subchild</loc></url><url><loc>https://example.com/parent/child</loc></url><url><loc>https://example.com/parent</loc></url><url><loc>https://example.com/sub</loc></url><url><loc>https://example.com/sub/sub</loc></url><url><loc>https://example.com/</loc></url></urlset>"`;
+
+exports[`sitemap - multiple configuration sitemap-bar.xml 1`] = `"<?xml version=\\"1.0\\" encoding=\\"UTF-8\\"?><urlset xmlns=\\"http://www.sitemaps.org/schemas/sitemap/0.9\\" xmlns:news=\\"http://www.google.com/schemas/sitemap-news/0.9\\" xmlns:xhtml=\\"http://www.w3.org/1999/xhtml\\" xmlns:mobile=\\"http://www.google.com/schemas/sitemap-mobile/1.0\\" xmlns:image=\\"http://www.google.com/schemas/sitemap-image/1.1\\" xmlns:video=\\"http://www.google.com/schemas/sitemap-video/1.1\\"><url><loc>https://example.org/child</loc></url><url><loc>https://example.org/exclude</loc></url><url><loc>https://example.org/filtered</loc></url><url><loc>https://example.org/parent/child/subchild</loc></url><url><loc>https://example.org/parent/child</loc></url><url><loc>https://example.org/parent</loc></url><url><loc>https://example.org/sub</loc></url><url><loc>https://example.org/sub/sub</loc></url><url><loc>https://example.org/</loc></url></urlset>"`;
+
+exports[`sitemap - multiple configuration sitemap-foo.xml 1`] = `"<?xml version=\\"1.0\\" encoding=\\"UTF-8\\"?><urlset xmlns=\\"http://www.sitemaps.org/schemas/sitemap/0.9\\" xmlns:news=\\"http://www.google.com/schemas/sitemap-news/0.9\\" xmlns:xhtml=\\"http://www.w3.org/1999/xhtml\\" xmlns:mobile=\\"http://www.google.com/schemas/sitemap-mobile/1.0\\" xmlns:image=\\"http://www.google.com/schemas/sitemap-image/1.1\\" xmlns:video=\\"http://www.google.com/schemas/sitemap-video/1.1\\"><url><loc>https://example.com/child</loc></url><url><loc>https://example.com/exclude</loc></url><url><loc>https://example.com/filtered</loc></url><url><loc>https://example.com/parent/child/subchild</loc></url><url><loc>https://example.com/parent/child</loc></url><url><loc>https://example.com/parent</loc></url><url><loc>https://example.com/sub</loc></url><url><loc>https://example.com/sub/sub</loc></url><url><loc>https://example.com/</loc></url></urlset>"`;
+
+exports[`sitemapindex - generate mode sitemap-bar.xml 1`] = `"<?xml version=\\"1.0\\" encoding=\\"UTF-8\\"?><urlset xmlns=\\"http://www.sitemaps.org/schemas/sitemap/0.9\\" xmlns:news=\\"http://www.google.com/schemas/sitemap-news/0.9\\" xmlns:xhtml=\\"http://www.w3.org/1999/xhtml\\" xmlns:mobile=\\"http://www.google.com/schemas/sitemap-mobile/1.0\\" xmlns:image=\\"http://www.google.com/schemas/sitemap-image/1.1\\" xmlns:video=\\"http://www.google.com/schemas/sitemap-video/1.1\\"><url><loc>https://example.fr/bar/1</loc></url><url><loc>https://example.fr/bar/2</loc></url><url><loc>https://example.fr/child</loc></url><url><loc>https://example.fr/exclude</loc></url><url><loc>https://example.fr/filtered</loc></url><url><loc>https://example.fr/parent/child/subchild</loc></url><url><loc>https://example.fr/parent/child</loc></url><url><loc>https://example.fr/parent</loc></url><url><loc>https://example.fr/sub</loc></url><url><loc>https://example.fr/sub/sub</loc></url><url><loc>https://example.fr/</loc></url></urlset>"`;
+
+exports[`sitemapindex - generate mode sitemap-foo.xml 1`] = `"<?xml version=\\"1.0\\" encoding=\\"UTF-8\\"?><urlset xmlns=\\"http://www.sitemaps.org/schemas/sitemap/0.9\\" xmlns:news=\\"http://www.google.com/schemas/sitemap-news/0.9\\" xmlns:xhtml=\\"http://www.w3.org/1999/xhtml\\" xmlns:mobile=\\"http://www.google.com/schemas/sitemap-mobile/1.0\\" xmlns:image=\\"http://www.google.com/schemas/sitemap-image/1.1\\" xmlns:video=\\"http://www.google.com/schemas/sitemap-video/1.1\\"><url><loc>https://example.com/foo/1</loc></url><url><loc>https://example.com/foo/2</loc></url><url><loc>https://example.com/child</loc></url><url><loc>https://example.com/exclude</loc></url><url><loc>https://example.com/filtered</loc></url><url><loc>https://example.com/parent/child/subchild</loc></url><url><loc>https://example.com/parent/child</loc></url><url><loc>https://example.com/parent</loc></url><url><loc>https://example.com/sub</loc></url><url><loc>https://example.com/sub/sub</loc></url><url><loc>https://example.com/</loc></url></urlset>"`;
+
+exports[`sitemapindex - generate mode sitemapindex.xml 1`] = `
+"<?xml version=\\"1.0\\" encoding=\\"UTF-8\\"?>
+<sitemapindex xmlns=\\"http://www.sitemaps.org/schemas/sitemap/0.9\\" xmlns:mobile=\\"http://www.google.com/schemas/sitemap-mobile/1.0\\" xmlns:image=\\"http://www.google.com/schemas/sitemap-image/1.1\\" xmlns:video=\\"http://www.google.com/schemas/sitemap-video/1.1\\">
+<sitemap>
+<loc>https://example.com/sitemap-foo.xml</loc>
+</sitemap>
+<sitemap>
+<loc>https://example.fr/sitemap-bar.xml</loc>
+</sitemap>
+</sitemapindex>"
+`;

test/fixture/nuxt.config.js

@@ -4,19 +4,36 @@ module.exports = {
     resourceHints: false
   },
   modules: [require('../..')],
-  sitemap: {
-    path: '/sitemap.xml',
-    exclude: ['/exclude'],
-    gzip: true,
-    hostname: 'http://localhost:3000/',
-    routes: ['1/', 'child/1', { url: 'test' }],
-    filter: ({ routes }) => routes.filter(route => route.url !== '/filtered'),
-    xmlNs: 'xmlns="http://www.sitemaps.org/schemas/sitemap/0.9"',
-    // xslUrl: 'sitemap.xsl',
-    trailingSlash: true,
-    defaults: {
-      changefreq: 'daily',
-      priority: 1
+  sitemap: [
+    {
+      path: '/sitemap.xml',
+      exclude: ['/exclude'],
+      gzip: true,
+      hostname: 'http://localhost:3000/',
+      routes: ['1/', 'child/1', { url: 'test' }],
+      filter: ({ routes }) => routes.filter(route => route.url !== '/filtered/'),
+      xmlNs: 'xmlns="http://www.sitemaps.org/schemas/sitemap/0.9"',
+      // xslUrl: 'sitemap.xsl',
+      trailingSlash: true,
+      defaults: {
+        changefreq: 'daily',
+        priority: 1
+      }
+    },
+    {
+      hostname: 'https://example.com/',
+      lastmod: new Date().toISOString(),
+      sitemaps: [
+        {
+          path: '/sitemap-foo.xml',
+          routes: ['foo/1', 'foo/2']
+        },
+        {
+          hostname: 'https://yolo.com/',
+          path: '/sitemap-bar.xml',
+          routes: ['bar/1', 'bar/2']
+        }
+      ]
     }
-  }
+  ]
 }

test/module.test.js

@@ -236,12 +236,154 @@ describe('sitemap - advanced configuration', () => {
   })
 })
 
+describe('sitemap - multiple configuration', () => {
+  let nuxt = null
+
+  beforeAll(async () => {
+    nuxt = await startServer({
+      ...config,
+      sitemap: [
+        {
+          path: 'sitemap-foo.xml',
+          hostname: 'https://example.com/'
+        },
+        {
+          path: 'sitemap-bar.xml',
+          hostname: 'https://example.org/'
+        }
+      ]
+    })
+  })
+
+  test('sitemap-foo.xml', async () => {
+    const xml = await get('/sitemap-foo.xml')
+    expect(xml).toMatchSnapshot()
+  })
+
+  test('sitemap-bar.xml', async () => {
+    const xml = await get('/sitemap-bar.xml')
+    expect(xml).toMatchSnapshot()
+  })
+
+  afterAll(async () => {
+    await nuxt.close()
+  })
+})
+
+describe('sitemapindex - minimal configuration', () => {
+  let nuxt = null
+
+  beforeAll(async () => {
+    nuxt = await startServer({
+      ...config,
+      sitemap: {
+        hostname: 'https://example.com/',
+        sitemaps: [
+          {
+            path: '/sitemap-foo.xml',
+            routes: ['foo/1', 'foo/2']
+          },
+          {
+            path: '/sitemap-bar.xml',
+            routes: ['bar/1', 'bar/2']
+          }
+        ]
+      }
+    })
+  })
+
+  test('sitemapindex.xml', async () => {
+    const xml = await get('/sitemapindex.xml')
+    expect(xml).toContain('<loc>https://example.com/sitemap-foo.xml</loc>')
+    expect(xml).toContain('<loc>https://example.com/sitemap-bar.xml</loc>')
+  })
+
+  test('sitemap-foo.xml', async () => {
+    const xml = await get('/sitemap-foo.xml')
+    expect(xml).toContain('<loc>https://example.com/foo/1</loc>')
+    expect(xml).toContain('<loc>https://example.com/foo/2</loc>')
+  })
+
+  test('sitemap-bar.xml', async () => {
+    const xml = await get('/sitemap-bar.xml')
+    expect(xml).toContain('<loc>https://example.com/bar/1</loc>')
+    expect(xml).toContain('<loc>https://example.com/bar/2</loc>')
+  })
+
+  afterAll(async () => {
+    await nuxt.close()
+  })
+})
+
+describe('sitemapindex - advanced configuration', () => {
+  let nuxt = null
+  let xml = null
+  const lastmod = new Date().toISOString()
+
+  beforeAll(async () => {
+    nuxt = await startServer({
+      ...config,
+      sitemap: {
+        path: '/sitemapindex.xml',
+        hostname: 'https://example.com/',
+        sitemaps: [
+          {
+            path: '/sitemap-foo.xml',
+            routes: ['foo/1', 'foo/2']
+          },
+          {
+            hostname: 'https://example.fr/',
+            path: '/sitemap-bar.xml',
+            routes: ['bar/1', 'bar/2']
+          }
+        ],
+        gzip: true,
+        lastmod,
+        xmlNs: 'xmlns="https://example.com/schemas/sitemap/0.9"',
+        xslUrl: 'sitemapindex.xsl'
+      }
+    })
+
+    xml = await get('/sitemapindex.xml')
+  })
+
+  test('cascading hostname', () => {
+    expect(xml).toContain('<loc>https://example.com/sitemap-foo.xml</loc>')
+    expect(xml).toContain('<loc>https://example.fr/sitemap-bar.xml</loc>')
+  })
+
+  test('gzip enabled', async () => {
+    const gz = await getGzip('/sitemapindex.xml.gz')
+    const sitemap = gunzipSync(gz).toString()
+    expect(xml).toEqual(sitemap)
+  })
+
+  test('custom lastmod', () => {
+    expect(xml).toContain(`<lastmod>${lastmod}</lastmod>`)
+  })
+
+  test('custom XML namespaces', () => {
+    expect(xml).toContain('<sitemapindex xmlns="https://example.com/schemas/sitemap/0.9">')
+  })
+
+  test('custom XSL', () => {
+    expect(xml).toContain('<?xml-stylesheet type="text/xsl" href="sitemapindex.xsl"?>')
+  })
+
+  afterAll(async () => {
+    await nuxt.close()
+  })
+})
+
+// TODO: describe('sitemapindex - multiple configuration', () => { ... })
+
 describe('sitemap - generate mode', () => {
   test('sitemap.xml', async () => {
     await runGenerate({
       ...config,
       sitemap: {
-        hostname: 'https://example.com/'
+        hostname: 'https://example.com/',
+        exclude: ['/exclude']
       }
     })
 
@@ -264,3 +406,48 @@ describe('sitemap - generate mode', () => {
     expect(xml).toEqual(sitemap)
   })
 })
+
+describe('sitemapindex - generate mode', () => {
+  beforeAll(async () => {
+    await runGenerate({
+      ...config,
+      sitemap: {
+        hostname: 'https://example.com/',
+        sitemaps: [
+          {
+            path: '/sitemap-foo.xml',
+            routes: ['foo/1', 'foo/2']
+          },
+          {
+            hostname: 'https://example.fr/',
+            path: '/sitemap-bar.xml',
+            routes: ['bar/1', 'bar/2']
+          }
+        ],
+        gzip: true
+      }
+    })
+  })
+
+  test('sitemapindex.xml', () => {
+    const xml = readFileSync(resolve(__dirname, '../dist/sitemapindex.xml'), 'utf8')
+    expect(xml).toMatchSnapshot()
+  })
+
+  test('sitemapindex.xml.gz', () => {
+    const xml = readFileSync(resolve(__dirname, '../dist/sitemapindex.xml'), 'utf8')
+    const gz = readFileSync(resolve(__dirname, '../dist/sitemapindex.xml.gz'))
+    const sitemapindex = gunzipSync(gz).toString()
+    expect(xml).toEqual(sitemapindex)
+  })
+
+  test('sitemap-foo.xml', () => {
+    const xml = readFileSync(resolve(__dirname, '../dist/sitemap-foo.xml'), 'utf8')
+    expect(xml).toMatchSnapshot()
+  })
+
+  test('sitemap-bar.xml', () => {
+    const xml = readFileSync(resolve(__dirname, '../dist/sitemap-bar.xml'), 'utf8')
+    expect(xml).toMatchSnapshot()
+  })
+})