Téléchargement next sitemap - Téléchargement du code source next sitemap

Table des matières

Commencer
- Installation
- Créer un fichier de configuration
- Construction de planapes
  - Fichier de configuration personnalisé
  - Construire des planaps avec PNPM
Index de site
Division un grand sitemap en plusieurs fichiers
Options de configuration
Fonction de transformation personnalisée
Exemple de configuration complète
Génération de sitemaps dynamiques / côté serveur
JSDOC de type

Commencer

Installation

yarn add next-sitemap

Créer un fichier de configuration

next-sitemap nécessite un fichier de configuration de base ( next-sitemap.config.js ) sous la racine de votre projet

✅ next-sitemap chargera les variables d'environnement des fichiers .env par défaut.

 /** @type {import('next-sitemap').IConfig} */
module . exports = {
  siteUrl : process . env . SITE_URL || 'https://example.com' ,
  generateRobotsTxt : true , // (optional)
  // ...other options
}

Construction de planapes

Ajouter le sitemap suivant comme votre script post-constructeur

{
  "build" : " next build " ,
  "postbuild" : " next-sitemap "
}

Fichier de configuration personnalisé

Vous pouvez également utiliser un fichier de configuration personnalisé au lieu de next-sitemap.config.js . Il suffit de passer --config <your-config-file>.js to Build Command (Exemple: personnalisé-config-file)

{
  "build" : " next build " ,
  "postbuild" : " next-sitemap --config awesome.config.js "
}

Construire des planaps avec PNPM

Lorsque vous utilisez PNPM, vous devez créer un fichier .npmrc à la racine de votre projet si vous souhaitez utiliser une étape post-constructeur:

 //.npmrc
enable-pre-post-scripts=true

Index sitemaps (facultatif)

Depuis next-sitemap v2.x, sitemap.xml sera l'index du site. Il contiendra des URL de tous les autres points de terminaison générés par site.

La génération de sitemap d'index peut être désactivée en réglant generateIndexSitemap: false dans le fichier de configuration du sitemap suivant. (Ceci est utile pour les petits sites de passe-temps qui ne nécessitent pas de site de site d'index) (exemple: non-index-sitemaps)

Division un grand sitemap en plusieurs fichiers

Définissez la propriété sitemapSize dans next-sitemap.config.js pour diviser un grand sitemap en plusieurs fichiers.

 /** @type {import('next-sitemap').IConfig} */
module . exports = {
  siteUrl : 'https://example.com' ,
  generateRobotsTxt : true ,
  sitemapSize : 7000 ,
}

Ci-dessus se trouve la configuration minimale pour diviser un grand plan du site. Lorsque le nombre d'URL dans un plan du site est supérieur à 7000, next-sitemap créera un site de site (par exemple, sitemap-0.xml, sitemap-1.xml) et index (par exemple sitemap.xml).

Options de configuration

propriété	description	taper
siteurl	URL de base de votre site Web	chaîne
sortie (facultative)	Modes de sortie suivants. Vérifiez la documentation.	`standalone` , `export`
ChangeFreq (facultatif)	Changer la fréquence. Par défaut `daily`	chaîne
priorité (facultative)	Priorité. Par défaut `0.7`	nombre
SiteMapBaseFileName (facultatif)	Le nom du fichier du site du site généré avant l'extension du fichier. `"sitemap"`	chaîne
AlternateRefs (facultatif)	Indique le support multi-langues par URL unique. Défaut `[]`	AlternateRef []
SiteMapSize (facultatif)	Divisez un grand plan du site en plusieurs fichiers en spécifiant la taille du site. Par défaut `5000`	nombre
AutolastMod (facultatif)	Ajoutez une propriété `<lastmod/>` . Par défaut `true`	vrai
exclure (facultatif)	Tableau de chemins relatifs (modèle de papier générique pris en charge) pour exclure de la liste sur `sitemap.xml` ou `sitemap-.xml` . par exemple: `['/page-0', '/page-', '/private/*']` . En dehors de cette option `next-sitemap` propose également une option `transform` personnalisée qui pourrait être utilisée pour exclure les URL qui correspondent aux modèles spécifiques	chaîne[]
Sourcedir (facultatif)	Next.js Build Directory. Par défaut `.next`	chaîne
outdir (facultatif)	Tous les fichiers générés seront exportés vers ce répertoire. `public` par défaut	chaîne
Transform (facultatif)	Une fonction de transformation, qui s'exécute pour chaque `relative-path` dans le plan du site. Le renvoi de la valeur `null` à partir de la fonction de transformation entraînera l'exclusion de ce `path` spécifique à partir de la liste de sitemap générée.	fonction asynchrone
Pathes supplémentaires (facultatif)	Fonction asynchrone qui renvoie une liste de chemins supplémentaires à ajouter à la liste du site de site généré.	fonction asynchrone
Générer unIndexsitemap	Générer des sitemaps d'index. Par défaut `true`	booléen
GeneraterObotStxt (facultatif)	Générez un fichier `robots.txt` et répertoriez les sitemaps générés. Par défaut `false`	booléen
robotstxtoptions.transformRobotStxt (facultatif)	Fonction de transformateur Robots.TXT personnalisé. (Exemple: Custom-Robots-Txt-Transformateur) Par défaut: `async(config, robotsTxt)=> robotsTxt`	fonction asynchrone
robotstxtoptions.polices (facultatif)	Politiques pour générer `robots.txt` . Défaut: `[{ userAgent: '*', allow: '/' }]`	Irobotpolicy []
robotstxtoptions.AdditionalSitemaps (facultatif)	Options pour ajouter des sitemaps supplémentaires à `robots.txt` Host Entry	chaîne[]
robotstxtoptions. y compris enneonIndexSitemaps (facultatif)	À partir de v2.4x, `robots.txt` générés.txt ne contiendra que l'URL du `index sitemap` et des points de terminaison fournis sur `robotsTxtOptions.additionalSitemaps` . Il s'agit d'éviter la soumission URL en double (une fois via index-sitemap -> sitemap-url et une fois via robots.txt -> hôte) Définissez cette option `true` pour ajouter tous les points de terminaison du site de site générés sur `robots.txt` `false` par défaut (recommandé)	booléen

Fonction de transformation personnalisée

La transformation personnalisée fournit une méthode d'extension pour ajouter, supprimer ou exclure path ou properties d'un ensemble d'URL. La fonction de transformation s'exécute pour chaque relative path dans le plan du site. Et utilisez l'objet key : value pour ajouter des propriétés dans le XML.

Le renvoi de la valeur null à partir de la fonction de transformation entraînera l'exclusion de ce relative-path spécifique de la liste de sitemap générée.

 /** @type {import('next-sitemap').IConfig} */
module . exports = {
  transform : async ( config , path ) => {
    // custom function to ignore the path
    if ( customIgnoreFunction ( path ) ) {
      return null
    }

    // only create changefreq along with path
    // returning partial properties will result in generation of XML field with only returned values.
    if ( customLimitedField ( path ) ) {
      // This returns `path` & `changefreq`. Hence it will result in the generation of XML field with `path` and  `changefreq` properties only.
      return {
        loc : path , // => this will be exported as http(s)://<config.siteUrl>/<path>
        changefreq : 'weekly' ,
      }
    }

    // Use default transformation for all other cases
    return {
      loc : path , // => this will be exported as http(s)://<config.siteUrl>/<path>
      changefreq : config . changefreq ,
      priority : config . priority ,
      lastmod : config . autoLastmod ? new Date ( ) . toISOString ( ) : undefined ,
      alternateRefs : config . alternateRefs ?? [ ] ,
    }
  } ,
}

Fonction de chemins supplémentaires

additionalPaths cette fonction peut être utile si vous avez une grande liste de pages, mais que vous ne voulez pas les rendre toutes et utiliser Fallback: true. Le résultat de l'exécution de cette fonction sera ajouté à la liste générale des chemins et traité avec sitemapSize . Vous êtes libre d'ajouter des chemins dynamiques, mais contrairement à additionalSitemap , vous n'avez pas besoin de diviser la liste des chemins en différents fichiers au cas où il y a beaucoup de chemins pour un fichier.

Si votre fonction renvoie un chemin qui existe déjà, il sera simplement mis à jour, la duplication ne se produira pas.

 /** @type {import('next-sitemap').IConfig} */
module . exports = {
  additionalPaths : async ( config ) => {
    const result = [ ]

    // required value only
    result . push ( { loc : '/additional-page-1' } )

    // all possible values
    result . push ( {
      loc : '/additional-page-2' ,
      changefreq : 'yearly' ,
      priority : 0.7 ,
      lastmod : new Date ( ) . toISOString ( ) ,

      // acts only on '/additional-page-2'
      alternateRefs : [
        {
          href : 'https://es.example.com' ,
          hreflang : 'es' ,
        } ,
        {
          href : 'https://fr.example.com' ,
          hreflang : 'fr' ,
        } ,
      ] ,
    } )

    // using transformation from the current configuration
    result . push ( await config . transform ( config , '/additional-page-3' ) )

    return result
  } ,
}

Google News, Image and Video Sitemap

L'ensemble d'URL peut contenir des sitemaps supplémentaires définis par Google. Ce sont du site de sitemap de Google, du site du site d'image ou du site du site vidéo. Vous pouvez ajouter les valeurs de ces sitemaps en mettant à jour l'entrée dans la fonction transform ou en l'ajoutant avec additionalPaths . Vous devez retourner une entrée de sitemap dans les deux cas, c'est donc le meilleur endroit pour mettre à jour la sortie. Cet exemple ajoutera une étiquette d'image et de news à chaque entrée, mais IRL vous l'utiliseriez bien sûr avec une certaine condition ou dans un résultat de additionalPaths .

 /** @type {import('next-sitemap').IConfig} */
const config = {
  transform : async ( config , path ) => {
    return {
      loc : path , // => this will be exported as http(s)://<config.siteUrl>/<path>
      changefreq : config . changefreq ,
      priority : config . priority ,
      lastmod : config . autoLastmod ? new Date ( ) . toISOString ( ) : undefined ,
      images : [ { loc : 'https://example.com/image.jpg' } ] ,
      news : {
        title : 'Article 1' ,
        publicationName : 'Google Scholar' ,
        publicationLanguage : 'en' ,
        date : new Date ( ) ,
      } ,
    }
  } ,
}

export default config

Exemple de configuration complète

Voici un exemple de configuration next-sitemap.config.js avec toutes les options

 /** @type {import('next-sitemap').IConfig} */

module . exports = {
  siteUrl : 'https://example.com' ,
  changefreq : 'daily' ,
  priority : 0.7 ,
  sitemapSize : 5000 ,
  generateRobotsTxt : true ,
  exclude : [ '/protected-page' , '/awesome/secret-page' ] ,
  alternateRefs : [
    {
      href : 'https://es.example.com' ,
      hreflang : 'es' ,
    } ,
    {
      href : 'https://fr.example.com' ,
      hreflang : 'fr' ,
    } ,
  ] ,
  // Default transformation function
  transform : async ( config , path ) => {
    return {
      loc : path , // => this will be exported as http(s)://<config.siteUrl>/<path>
      changefreq : config . changefreq ,
      priority : config . priority ,
      lastmod : config . autoLastmod ? new Date ( ) . toISOString ( ) : undefined ,
      alternateRefs : config . alternateRefs ?? [ ] ,
    }
  } ,
  additionalPaths : async ( config ) => [
    await config . transform ( config , '/additional-page' ) ,
  ] ,
  robotsTxtOptions : {
    policies : [
      {
        userAgent : '*' ,
        allow : '/' ,
      } ,
      {
        userAgent : 'test-bot' ,
        allow : [ '/path' , '/path-2' ] ,
      } ,
      {
        userAgent : 'black-listed-bot' ,
        disallow : [ '/sub-path-1' , '/path-2' ] ,
      } ,
    ] ,
    additionalSitemaps : [
      'https://example.com/my-custom-sitemap-1.xml' ,
      'https://example.com/my-custom-sitemap-2.xml' ,
      'https://example.com/my-custom-sitemap-3.xml' ,
    ] ,
  } ,
}

La configuration ci-dessus générera des sitemaps en fonction de votre projet et d'un robots.txt comme celui-ci.

 # *
User-agent: *
Allow: /

# test-bot
User-agent: test-bot
Allow: /path
Allow: /path-2

# black-listed-bot
User-agent: black-listed-bot
Disallow: /sub-path-1
Disallow: /path-2

# Host
Host: https://example.com

# Sitemaps
Sitemap: https://example.com/sitemap.xml # Index sitemap
Sitemap: https://example.com/my-custom-sitemap-1.xml
Sitemap: https://example.com/my-custom-sitemap-2.xml
Sitemap: https://example.com/my-custom-sitemap-3.xml

Génération de sitemaps dynamiques / côté serveur

next-sitemap fournit désormais deux API pour générer des sitemaps côté serveur. Cela aidera à générer dynamiquement le (s) index-sitemap (s) et sitemap (s) en approvisionnement des données à partir de CMS ou de source personnalisée.

getServerSideSitemapIndex : génère des sitemaps d'index basés sur les URL fournies et renvoie une réponse application/xml . Prend en charge le fichier Next13 + Route. {TS, JS}.
- Pour continuer à utiliser le répertoire des pages à l'intérieur, importez plutôt getServerSideSitemapIndexLegacy .
getServerSideSitemap : génère du site de site en fonction des entrées de champ et renvoie une réponse application/xml . Prend en charge le fichier Next13 + Route. {TS, JS}.
- Pour continuer à utiliser le répertoire à l'intérieur des pages, importez plutôt getServerSideSitemapLegacy .

Index-sitemaps côté serveur (getSerVersiSiteMapIndex)

Voici un exemple de script pour générer du sitemap d'index du côté serveur.

1. INDEX SITEMAP (répertoire de l'APP)

Créez app/server-sitemap-index.xml/route.ts fichier.

 // app/server-sitemap-index.xml/route.ts
import { getServerSideSitemapIndex } from 'next-sitemap'

export async function GET ( request : Request ) {
  // Method to source urls from cms
  // const urls = await fetch('https//example.com/api')

  return getServerSideSitemapIndex ( [
    'https://example.com/path-1.xml' ,
    'https://example.com/path-2.xml' ,
  ] )
}

Créer pages/server-sitemap-index.xml/index.tsx fichiers.

 // pages/server-sitemap-index.xml/index.tsx
import { getServerSideSitemapIndexLegacy } from 'next-sitemap'
import { GetServerSideProps } from 'next'

export const getServerSideProps : GetServerSideProps = async ( ctx ) => {
  // Method to source urls from cms
  // const urls = await fetch('https//example.com/api')

  return getServerSideSitemapIndexLegacy ( ctx , [
    'https://example.com/path-1.xml' ,
    'https://example.com/path-2.xml' ,
  ] )
}

// Default export to prevent next.js errors
export default function SitemapIndex ( ) { }

Exclure le site du site du serveur à partir de robots.txt

Maintenant, next.js sert l'index dynamique-sitemap à partir de http://localhost:3000/server-sitemap-index.xml .

Énumérez la page Dynamic Sitemap dans robotsTxtOptions.additionalSitemaps et excluez ce chemin de la liste statique de la liste du site.

 // next-sitemap.config.js

/** @type {import('next-sitemap').IConfig} */
module . exports = {
  siteUrl : 'https://example.com' ,
  generateRobotsTxt : true ,
  exclude : [ '/server-sitemap-index.xml' ] , // <= exclude here
  robotsTxtOptions : {
    additionalSitemaps : [
      'https://example.com/server-sitemap-index.xml' , // <==== Add here
    ] ,
  } ,
}

De cette façon, next-sitemap Gérera les sitemaps pour toutes vos pages statiques et votre index-sitemap dynamique sera répertorié sur robots.txt.

Sitemap côté serveur (getSerVersideItemap)

Voici un exemple de script pour générer des sitemaps côté serveur.

1. Sitemaps (répertoire de l'application)

Créez un fichier app/server-sitemap.xml/route.ts .

 // app/server-sitemap.xml/route.ts
import { getServerSideSitemap } from 'next-sitemap'

export async function GET ( request : Request ) {
  // Method to source urls from cms
  // const urls = await fetch('https//example.com/api')

  return getServerSideSitemap ( [
    {
      loc : 'https://example.com' ,
      lastmod : new Date ( ) . toISOString ( ) ,
      // changefreq
      // priority
    } ,
    {
      loc : 'https://example.com/dynamic-path-2' ,
      lastmod : new Date ( ) . toISOString ( ) ,
      // changefreq
      // priority
    } ,
  ] )
}

2. Sitemaps (répertoire des pages) (héritage)

Créez pages/server-sitemap.xml/index.tsx fichiers.

 // pages/server-sitemap.xml/index.tsx
import { getServerSideSitemapLegacy } from 'next-sitemap'
import { GetServerSideProps } from 'next'

export const getServerSideProps : GetServerSideProps = async ( ctx ) => {
  // Method to source urls from cms
  // const urls = await fetch('https//example.com/api')

  const fields = [
    {
      loc : 'https://example.com' , // Absolute url
      lastmod : new Date ( ) . toISOString ( ) ,
      // changefreq
      // priority
    } ,
    {
      loc : 'https://example.com/dynamic-path-2' , // Absolute url
      lastmod : new Date ( ) . toISOString ( ) ,
      // changefreq
      // priority
    } ,
  ]

  return getServerSideSitemapLegacy ( ctx , fields )
}

// Default export to prevent next.js errors
export default function Sitemap ( ) { }

Maintenant, next.js sert le site dynamique à partir de http://localhost:3000/server-sitemap.xml .

Énumérez la page Dynamic Sitemap dans robotsTxtOptions.additionalSitemaps et excluez ce chemin de la liste statique de la liste du site.

 // next-sitemap.config.js

/** @type {import('next-sitemap').IConfig} */
module . exports = {
  siteUrl : 'https://example.com' ,
  generateRobotsTxt : true ,
  exclude : [ '/server-sitemap.xml' ] , // <= exclude here
  robotsTxtOptions : {
    additionalSitemaps : [
      'https://example.com/server-sitemap.xml' , // <==== Add here
    ] ,
  } ,
}

De cette façon, next-sitemap gérera les sitemaps pour toutes vos pages statiques et votre site de site dynamique sera répertorié sur robots.txt.

JSDOC de type

Ajoutez la ligne de code suivante dans votre next-sitemap.config.js pour une belle assortie automatique! ?

 /** @type {import('next-sitemap').IConfig} */
module . exports = {
  // YOUR CONFIG
}

Ts_jsdoc

Contribution

Tous les PR sont les bienvenus :)

Développer

next sitemap

Table des matières

Commencer

Installation

Créer un fichier de configuration

Construction de planapes

Fichier de configuration personnalisé

Construire des planaps avec PNPM

Index sitemaps (facultatif)

Division un grand sitemap en plusieurs fichiers

Options de configuration

Fonction de transformation personnalisée

Fonction de chemins supplémentaires

Google News, Image and Video Sitemap

Exemple de configuration complète

Génération de sitemaps dynamiques / côté serveur

Index-sitemaps côté serveur (getSerVersiSiteMapIndex)

Exclure le site du site du serveur à partir de robots.txt

Sitemap côté serveur (getSerVersideItemap)

JSDOC de type

Contribution

next saas starter

LLaVA NeXT

Application Next Todo

Xanadu Suivant

Générateur automatique Google SiteMap

Générateur de plan de site Google

chat.petals.dev

GPT Prompt Templates

GPTyped

ML stack

awesome free chatgpt

pywin_contextmenu

Google Dorks

shepherd

mongo express