1- import { defu } from 'defu'
21import { resolveSitePath } from 'site-config-stack/urls'
3- import { parseURL , withHttps } from 'ufo'
2+ import { joinURL , withHttps } from 'ufo'
43import type {
4+ AlternativeEntry , AutoI18nConfig ,
55 ModuleRuntimeConfig ,
66 NitroUrlResolvers ,
77 ResolvedSitemapUrl ,
88 SitemapDefinition ,
9- SitemapRenderCtx ,
9+ SitemapSourceResolved ,
1010 SitemapUrlInput ,
1111} from '../../../types'
12- import { normaliseSitemapUrls } from '../urlset/normalise'
12+ import { preNormalizeEntry } from '../urlset/normalise'
1313import { childSitemapSources , globalSitemapSources , resolveSitemapSources } from '../urlset/sources'
14- import { filterSitemapUrls } from '../urlset/filter'
15- import { applyI18nEnhancements , normaliseI18nSources } from '../urlset/i18n'
1614import { sortSitemapUrls } from '../urlset/sort'
17- import { splitForLocales } from '../../utils'
18- import { createNitroRouteRuleMatcher } from '../../kit'
15+ import { createPathFilter , logger , splitForLocales } from '../../../utils-pure'
1916import { handleEntry , wrapSitemapXml } from './xml'
20- import { useNitroApp } from '#imports'
2117
22- export async function buildSitemap ( sitemap : SitemapDefinition , resolvers : NitroUrlResolvers , runtimeConfig : ModuleRuntimeConfig ) {
18+ export interface NormalizedI18n extends ResolvedSitemapUrl {
19+ _pathWithoutPrefix : string
20+ _locale : AutoI18nConfig [ 'locales' ] [ number ]
21+ _index ?: number
22+ }
23+
24+ export function resolveSitemapEntries ( sitemap : SitemapDefinition , sources : SitemapSourceResolved [ ] , runtimeConfig : Pick < ModuleRuntimeConfig , 'autoI18n' | 'isI18nMapped' > ) : ResolvedSitemapUrl [ ] {
25+ const {
26+ autoI18n,
27+ isI18nMapped,
28+ } = runtimeConfig
29+ const filterPath = createPathFilter ( {
30+ include : sitemap . include ,
31+ exclude : sitemap . exclude ,
32+ } )
33+ // 1. normalise
34+ const _urls = sources . flatMap ( e => e . urls ) . map ( ( _e ) => {
35+ const e = preNormalizeEntry ( _e )
36+ if ( ! e . loc || ! filterPath ( e . loc ) )
37+ return false
38+ return e
39+ } ) . filter ( Boolean ) as ResolvedSitemapUrl [ ]
40+
41+ let validI18nUrlsForTransform : NormalizedI18n [ ] = [ ]
42+ let warnIncorrectI18nTransformUsage = false
43+ const withoutPrefixPaths : Record < string , NormalizedI18n [ ] > = { }
44+ if ( autoI18n && autoI18n . strategy !== 'no_prefix' ) {
45+ const localeCodes = autoI18n . locales . map ( l => l . code )
46+ validI18nUrlsForTransform = _urls . map ( ( _e , i ) => {
47+ if ( _e . _abs )
48+ return false
49+ const split = splitForLocales ( _e . loc , localeCodes )
50+ let localeCode = split [ 0 ]
51+ const pathWithoutPrefix = split [ 1 ]
52+ if ( ! localeCode )
53+ localeCode = autoI18n . defaultLocale
54+ const e = _e as NormalizedI18n
55+ e . _pathWithoutPrefix = pathWithoutPrefix
56+ const locale = autoI18n . locales . find ( l => l . code === localeCode ) !
57+ if ( ! locale )
58+ return false
59+ e . _locale = locale
60+ e . _index = i
61+ withoutPrefixPaths [ pathWithoutPrefix ] = withoutPrefixPaths [ pathWithoutPrefix ] || [ ]
62+ // need to make sure the locale doesn't already exist
63+ if ( ! withoutPrefixPaths [ pathWithoutPrefix ] . some ( e => e . _locale . code === locale . code ) )
64+ withoutPrefixPaths [ pathWithoutPrefix ] . push ( e )
65+ return e
66+ } ) . filter ( Boolean ) as NormalizedI18n [ ]
67+
68+ for ( const e of validI18nUrlsForTransform ) {
69+ // let's try and find other urls that we can use for alternatives
70+ if ( ! e . _i18nTransform && ! e . alternatives ?. length ) {
71+ const alternatives = withoutPrefixPaths [ e . _pathWithoutPrefix ]
72+ . map ( ( u ) => {
73+ const entries : AlternativeEntry [ ] = [ ]
74+ if ( u . _locale . code === autoI18n . defaultLocale ) {
75+ entries . push ( {
76+ href : u . loc ,
77+ hreflang : 'x-default' ,
78+ } )
79+ }
80+ entries . push ( {
81+ href : u . loc ,
82+ hreflang : u . _locale . code || autoI18n . defaultLocale ,
83+ } )
84+ return entries
85+ } )
86+ . flat ( )
87+ . filter ( Boolean ) as AlternativeEntry [ ]
88+ if ( alternatives . length )
89+ e . alternatives = alternatives
90+ }
91+ else if ( e . _i18nTransform ) {
92+ delete e . _i18nTransform
93+ if ( autoI18n . strategy === 'no_prefix' ) {
94+ warnIncorrectI18nTransformUsage = true
95+ }
96+ // keep single entry, just add alternatvies
97+ if ( autoI18n . differentDomains ) {
98+ e . alternatives = [
99+ {
100+ // apply default locale domain
101+ ...autoI18n . locales . find ( l => [ l . code , l . iso ] . includes ( autoI18n . defaultLocale ) ) ,
102+ code : 'x-default' ,
103+ } ,
104+ ...autoI18n . locales
105+ . filter ( l => ! ! l . domain ) ,
106+ ]
107+ . map ( ( locale ) => {
108+ return {
109+ hreflang : locale . iso || locale . code ,
110+ href : joinURL ( withHttps ( locale . domain ! ) , e . _pathWithoutPrefix ) ,
111+ }
112+ } )
113+ }
114+ else {
115+ // need to add urls for all other locales
116+ for ( const l of autoI18n . locales ) {
117+ let loc = joinURL ( `/${ l . code } , e . _pathWithoutPrefix )
118+ if ( autoI18n . differentDomains || ( [ 'prefix_and_default' , 'prefix_except_default' ] . includes ( autoI18n . strategy ) && l . code === autoI18n . defaultLocale ) )
119+ loc = e . _pathWithoutPrefix
120+ const _sitemap = isI18nMapped ? ( l . iso || l . code ) : undefined
121+ const newEntry : NormalizedI18n = preNormalizeEntry ( {
122+ _sitemap,
123+ ...e ,
124+ _index : undefined ,
125+ _key : `${ _sitemap || '' } ${ loc } ,
126+ _locale : l ,
127+ loc,
128+ alternatives : [ { code : 'x-default' } , ...autoI18n . locales ] . map ( ( locale ) => {
129+ const code = locale . code === 'x-default' ? autoI18n . defaultLocale : locale . code
130+ const isDefault = locale . code === 'x-default' || locale . code === autoI18n . defaultLocale
131+ let href = ''
132+ if ( autoI18n . strategy === 'prefix' ) {
133+ href = joinURL ( '/' , code , e . _pathWithoutPrefix )
134+ } else if ( [ 'prefix_and_default' , 'prefix_except_default' ] . includes ( autoI18n . strategy ) ) {
135+ if ( isDefault ) {
136+ // no prefix
137+ href = e . _pathWithoutPrefix
138+ } else {
139+ href = joinURL ( '/' , code , e . _pathWithoutPrefix )
140+ }
141+ }
142+ const hreflang = locale . iso || locale . code
143+ if ( ! filterPath ( href ) )
144+ return false
145+ return {
146+ hreflang,
147+ href,
148+ }
149+ } ) . filter ( Boolean ) ,
150+ } )
151+ if ( e . _locale . code === newEntry . _locale . code ) {
152+ // replace
153+ _urls [ e . _index ] = newEntry
154+ // avoid getting re-replaced
155+ e . _index = undefined
156+ } else {
157+ _urls . push ( newEntry )
158+ }
159+ }
160+ }
161+ }
162+ if ( isI18nMapped ) {
163+ e . _sitemap = e . _sitemap || e . _locale . iso || e . _locale . code
164+ }
165+ if ( e . _index )
166+ _urls [ e . _index ] = e
167+ }
168+ }
169+ if ( import . meta. dev && warnIncorrectI18nTransformUsage ) {
170+ logger . warn ( 'You\'re using _i18nTransform with the `no_prefix` strategy. This will cause issues with the sitemap. Please remove the _i18nTransform flag or change i18n strategy.' )
171+ }
172+ return _urls
173+ }
174+
175+ export async function buildSitemapUrls ( sitemap : SitemapDefinition , resolvers : NitroUrlResolvers , runtimeConfig : ModuleRuntimeConfig ) {
23176 // 0. resolve sources
24177 // 1. normalise
25178 // 2. filter
@@ -38,10 +191,6 @@ export async function buildSitemap(sitemap: SitemapDefinition, resolvers: NitroU
38191 sortEntries,
39192 // chunking
40193 defaultSitemapsChunkSize,
41- // xls
42- version,
43- xsl,
44- credits,
45194 } = runtimeConfig
46195 const isChunking = typeof sitemaps . chunks !== 'undefined' && ! Number . isNaN ( Number ( sitemap . sitemapName ) )
47196 function maybeSort ( urls : ResolvedSitemapUrl [ ] ) {
@@ -71,65 +220,24 @@ export async function buildSitemap(sitemap: SitemapDefinition, resolvers: NitroU
71220 // always fetch all sitemap data for the primary sitemap
72221 const sources = sitemap . includeAppSources ? await globalSitemapSources ( ) : [ ]
73222 sources . push ( ...await childSitemapSources ( sitemap ) )
74- let resolvedSources = await resolveSitemapSources ( sources , resolvers . event )
75- // normalise the sources for i18n
76- if ( autoI18n )
77- resolvedSources = normaliseI18nSources ( resolvedSources , { autoI18n, isI18nMapped, ...sitemap } )
78- // 1. normalise
79- const normalisedUrls = normaliseSitemapUrls ( resolvedSources . map ( e => e . urls ) . flat ( ) , resolvers )
80-
81- const routeRuleMatcher = createNitroRouteRuleMatcher ( )
82- let enhancedUrls : ResolvedSitemapUrl [ ] = normalisedUrls
83- // apply defaults
84- . map ( e => defu ( e , sitemap . defaults ) as ResolvedSitemapUrl )
85- // apply route rules
86- . map ( ( e ) => {
87- const path = parseURL ( e . loc ) . pathname
88- let routeRules = routeRuleMatcher ( path )
89- // apply top-level path without prefix, users can still target the localed path
90- if ( autoI18n ?. locales && autoI18n ?. strategy !== 'no_prefix' ) {
91- // remove the locale path from the prefix, if it exists, need to use regex
92- const match = splitForLocales ( path , autoI18n . locales . map ( l => l . code ) )
93- const pathWithoutPrefix = match [ 1 ]
94- if ( pathWithoutPrefix && pathWithoutPrefix !== path )
95- routeRules = defu ( routeRules , routeRuleMatcher ( pathWithoutPrefix ) )
96- }
97-
98- if ( routeRules . sitemap === false )
99- return false
100- if ( typeof routeRules . index !== 'undefined' && ! routeRules . index )
101- return false
102- const hasRobotsDisabled = Object . entries ( routeRules . headers || { } )
103- . some ( ( [ name , value ] ) => name . toLowerCase ( ) === 'x-robots-tag' && value . toLowerCase ( ) === 'noindex' )
104- // check for redirects and headers which aren't indexable
105- if ( routeRules . redirect || hasRobotsDisabled )
106- return false
223+ const resolvedSources = await resolveSitemapSources ( sources , resolvers . event )
107224
108- return routeRules . sitemap ? defu ( e , routeRules . sitemap ) as ResolvedSitemapUrl : e
109- } )
110- . filter ( Boolean ) as ResolvedSitemapUrl [ ]
111- // TODO enable
112- if ( autoI18n ?. locales )
113- enhancedUrls = applyI18nEnhancements ( enhancedUrls , { isI18nMapped, autoI18n, ...sitemap } )
225+ const enhancedUrls = resolveSitemapEntries ( sitemap , resolvedSources , { autoI18n, isI18nMapped } )
114226 // 3. filtered urls
115227 // TODO make sure include and exclude start with baseURL?
116- const filteredUrls = filterSitemapUrls ( enhancedUrls , { event : resolvers . event , isMultiSitemap, autoI18n, ...sitemap } )
228+ const filteredUrls = enhancedUrls . filter ( ( e ) => {
229+ if ( isMultiSitemap && e . _sitemap && sitemap . sitemapName )
230+ return e . _sitemap === sitemap . sitemapName
231+ return true
232+ } )
117233 // 4. sort
118234 const sortedUrls = maybeSort ( filteredUrls )
119235 // 5. maybe slice for chunked
120236 // if we're rendering a partial sitemap, slice the entries
121- const slicedUrls = maybeSlice ( sortedUrls )
122- // 6. nitro hooks
123- const nitro = useNitroApp ( )
124- const ctx : SitemapRenderCtx = {
125- urls : slicedUrls ,
126- sitemapName : sitemap . sitemapName ,
127- }
128- await nitro . hooks . callHook ( 'sitemap:resolved' , ctx )
129-
130- // final urls
131- const urls = maybeSort ( normaliseSitemapUrls ( ctx . urls , resolvers ) )
237+ return maybeSlice ( sortedUrls )
238+ }
132239
240+ export function urlsToXml ( urls : ResolvedSitemapUrl [ ] , resolvers : NitroUrlResolvers , { version, xsl, credits } : Pick < ModuleRuntimeConfig , 'version' | 'xsl' | 'credits' > ) {
133241 const urlset = urls . map ( ( e ) => {
134242 const keys = Object . keys ( e ) . filter ( k => ! k . startsWith ( '_' ) )
135243 return [
0 commit comments