feat: enhance internationalization support with dynamic routing

src/config/index.ts

@@ -33,7 +33,6 @@ export const themeConfig: ThemeConfig = {
     locale: 'zh', // zh, zh-tw, ja, en, es, ru, default locale setting
     moreLocale: ['zh-tw', 'ja', 'en', 'es', 'ru'], // ['zh-tw', 'ja', 'en', 'es', 'ru']， not fill in the default locale code again
     font: 'sans', // sans, serif, choose the font style for posts
-    rss: true, // true, false, whether to enable RSS
     toc: true, // true, false, whether to enable table of contents in posts
   },
   // GLOBAL SETTINGS >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> END

src/pages/[lang]/about.astro

@@ -1,5 +1,12 @@
 ---
+import { themeConfig } from '@/config'
 import Layout from '@/layouts/Layout.astro'
+
+export function getStaticPaths() {
+  return themeConfig.global.moreLocale.map(lang => ({
+    params: { lang },
+  }))
+}
 ---
 
 <Layout>

src/pages/[lang]/index.astro

@@ -1,12 +1,12 @@
 ---
+import { themeConfig } from '@/config'
 import Layout from '@/layouts/Layout.astro'
 import { getPinnedPosts, getPosts } from '@/utils/content.config'
 
 export function getStaticPaths() {
-  return [
-    { params: { lang: 'zh' } },
-    { params: { lang: 'en' } },
-  ]
+  return themeConfig.global.moreLocale.map(lang => ({
+    params: { lang },
+  }))
 }
 
 const { lang } = Astro.params

src/pages/[lang]/posts/[slug].astro

@@ -1,13 +1,16 @@
 ---
+import { themeConfig } from '@/config'
 import Layout from '@/layouts/Layout.astro'
 import { getCollection } from 'astro:content'
 
 export async function getStaticPaths() {
   const posts = await getCollection('posts')
-  return posts.map(post => ({
-    params: { slug: post.slug },
-    props: { post },
-  }))
+  return themeConfig.global.moreLocale.flatMap(lang =>
+    posts.map(post => ({
+      params: { lang, slug: post.slug },
+      props: { post },
+    })),
+  )
 }
 
 const { post } = Astro.props

src/pages/[lang]/rss.xml.ts

@@ -0,0 +1,86 @@
+import type { APIContext } from 'astro'
+import type { CollectionEntry } from 'astro:content'
+import themeConfig from '@/config'
+import rss from '@astrojs/rss'
+import { getCollection } from 'astro:content'
+import MarkdownIt from 'markdown-it'
+import sanitizeHtml from 'sanitize-html'
+
+const parser = new MarkdownIt()
+const { title, description, url } = themeConfig.site
+const { locale: defaultLocale, moreLocale } = themeConfig.global
+const followConfig = themeConfig.seo?.follow
+
+// Extract first 100 chars from content as description
+function getExcerpt(content: string): string {
+  const plainText = sanitizeHtml(
+    parser.render(content),
+    {
+      allowedTags: [],
+      allowedAttributes: {},
+    },
+  )
+
+  return `${plainText.slice(0, 100).trim()}...`
+}
+
+// Return 404 response for invalid language routes
+function return404() {
+  return new Response(null, {
+    status: 404,
+    statusText: 'Not found',
+  })
+}
+
+// Add getStaticPaths for dynamic routes
+export function getStaticPaths() {
+  return moreLocale.map(lang => ({ params: { lang } }))
+}
+
+// Generate RSS feed for non-default languages
+export async function GET({ params }: APIContext) {
+  const lang = params.lang as string
+
+  // Only generate RSS for valid non-default languages
+  if (!moreLocale.includes(lang)) {
+    return return404()
+  }
+
+  // Get posts for specific language (include universal posts)
+  const posts = await getCollection(
+    'posts',
+    ({ data }: { data: CollectionEntry<'posts'>['data'] }) =>
+      (!data.draft && (data.lang === lang || data.lang === '')),
+  )
+
+  return rss({
+    title: `${title} (${lang})`,
+    description,
+    site: url,
+    stylesheet: '/rss/styles.xsl',
+    // Map posts to RSS items with language-specific URLs
+    items: posts.map(post => ({
+      title: post.data.title,
+      pubDate: post.data.published,
+      description: post.data.description || getExcerpt(post.body),
+      link: `/${lang}/posts/${post.slug}/`,
+      content: sanitizeHtml(
+        parser.render(post.body),
+        {
+          allowedTags: sanitizeHtml.defaults.allowedTags.concat(['img']),
+        },
+      ),
+    })),
+    // Add language and follow challenge info
+    customData: `
+      <language>${lang}</language>
+      ${followConfig?.feedID && followConfig?.userID
+          ? `<follow_challenge>
+          <feedId>${followConfig.feedID}</feedId>
+          <userId>${followConfig.userID}</userId>
+        </follow_challenge>`
+          : ''
+      }
+    `.trim(),
+  })
+}

src/pages/[lang]/tags/[tags].astro

@@ -1,15 +1,19 @@
 ---
+import { themeConfig } from '@/config'
 import Layout from '@/layouts/Layout.astro'
 import { getAllTags, getPostsByTag } from '@/utils/content.config'
 
 export async function getStaticPaths() {
   const tags = await getAllTags()
-  return tags.map(tag => ({
-    params: { tags: tag },
-    props: { tags: tag },
-  }))
+  return themeConfig.global.moreLocale.flatMap(lang =>
+    tags.map(tag => ({
+      params: { lang, tags: tag },
+      props: { tags: tag },
+    })),
+  )
 }
 
+const { lang } = Astro.params
 const { tags } = Astro.props
 const posts = await getPostsByTag(tags)
 const allTags = await getAllTags()
@@ -18,7 +22,7 @@ const allTags = await getAllTags()
 <Layout>
   <div>
     {allTags.map(tag => (
-      <a href={`/tags/${tag}/`}>
+      <a href={`/${lang}/tags/${tag}/`}>
         {tag}
       </a>
     ))}
@@ -28,7 +32,7 @@ const allTags = await getAllTags()
     <ul>
       {posts.map(post => (
         <li>
-          <a href={`/posts/${post.slug}/`}>{post.data.title}</a>
+          <a href={`/${lang}/posts/${post.slug}/`}>{post.data.title}</a>
         </li>
       ))}
     </ul>

src/pages/[lang]/tags/index.astro

@@ -1,14 +1,22 @@
 ---
+import { themeConfig } from '@/config'
 import Layout from '@/layouts/Layout.astro'
 import { getAllTags } from '@/utils/content.config'
 
+export function getStaticPaths() {
+  return themeConfig.global.moreLocale.map(lang => ({
+    params: { lang },
+  }))
+}
+
+const { lang } = Astro.params
 const allTags = await getAllTags()
 ---
 
 <Layout>
   <div>
     {allTags.map(tag => (
-      <a href={`/tags/${tag}/`}>
+      <a href={`/${lang}/tags/${tag}/`}>
         {tag}
       </a>
     ))}

src/pages/rss.xml.ts

@@ -24,11 +24,13 @@ function getExcerpt(content: string): string {
   return `${plainText.slice(0, 100).trim()}...`
 }
 
-// Generate RSS feed
-export async function GET(_context: APIContext) {
+// Generate RSS feed for default language
+export async function GET() {
+  // Only handle posts for default language
   const posts = await getCollection(
     'posts',
-    ({ data }: { data: CollectionEntry<'posts'>['data'] }) => !data.draft,
+    ({ data }: { data: CollectionEntry<'posts'>['data'] }) =>
+      (!data.draft && (data.lang === locale || data.lang === '')),
   )
 
   return rss({
@@ -36,6 +38,7 @@ export async function GET(_context: APIContext) {
     description,
     site: url,
     stylesheet: '/rss/styles.xsl',
+    // Map posts to RSS items
     items: posts.map((post: CollectionEntry<'posts'>) => ({
       title: post.data.title,
       pubDate: post.data.published,
@@ -48,13 +51,14 @@ export async function GET(_context: APIContext) {
         },
       ),
     })),
+    // Add language and follow challenge info
     customData: `
       <language>${locale}</language>
       ${followConfig?.feedID && followConfig?.userID
           ? `<follow_challenge>
-            <feedId>${followConfig.feedID}</feedId>
-            <userId>${followConfig.userID}</userId>
-          </follow_challenge>`
+          <feedId>${followConfig.feedID}</feedId>
+          <userId>${followConfig.userID}</userId>
+        </follow_challenge>`
           : ''
       }
     `.trim(),

src/types/index.d.ts

@@ -29,7 +29,6 @@ export interface ThemeConfig {
     locale: typeof langPath[number]
     moreLocale: typeof langPath[number][]
     font: string
-    rss: boolean
     toc: boolean
   }
 

src/utils/content.config.ts

@@ -1,17 +1,25 @@
 import type { CollectionEntry } from 'astro:content'
+import themeConfig from '@/config'
+import { langPath } from '@/utils/ui'
 import { getCollection } from 'astro:content'
 
 export type Post = CollectionEntry<'posts'>
 export type PostData = Post['data']
 export type PostsGroupByYear = Map<number, Post[]>
 
-// Get all posts and sort by publish date
-export async function getPosts() {
+// Get all posts except drafts (include pinned)
+export async function getPosts(lang?: string) {
+  const defaultLocale = themeConfig.global.locale
+  const currentLang = lang || defaultLocale
+
   const posts = await getCollection(
     'posts',
     ({ data }: Post) => {
-      const shouldInclude = (import.meta.env.DEV || !data.draft) && !data.pin
-      return shouldInclude
+      const shouldInclude = import.meta.env.DEV || !data.draft
+      if (!langPath.includes(currentLang)) {
+        return shouldInclude && data.lang === ''
+      }
+      return shouldInclude && (data.lang === currentLang || data.lang === '')
     },
   )
 
@@ -20,27 +28,23 @@ export async function getPosts() {
   )
 }
 
+// Get all posts except drafts (not pinned)
+export async function getRegularPosts(lang?: string) {
+  const posts = await getPosts(lang)
+  return posts.filter(post => !post.data.pin)
+}
+
 // Get pinned posts
-export async function getPinnedPosts() {
-  const posts = await getCollection(
-    'posts',
-    ({ data }: Post) => {
-      const shouldInclude = (import.meta.env.DEV || !data.draft) && data.pin
-      return shouldInclude
-    },
-  )
-
-  return posts.sort((a: Post, b: Post) =>
-    b.data.published.valueOf() - a.data.published.valueOf(),
-  )
+export async function getPinnedPosts(lang?: string) {
+  const posts = await getPosts(lang)
+  return posts.filter(post => post.data.pin)
 }
 
-// Group posts by year and sort
-export async function getPostsByYear(): Promise<PostsGroupByYear> {
-  const posts = await getPosts()
+// Get posts group by year (not pinned)
+export async function getPostsByYear(lang?: string): Promise<PostsGroupByYear> {
+  const posts = await getRegularPosts(lang)
   const yearMap = new Map<number, Post[]>()
 
-  // Group by year
   posts.forEach((post: Post) => {
     const year = post.data.published.getFullYear()
     if (!yearMap.has(year)) {
@@ -49,7 +53,6 @@ export async function getPostsByYear(): Promise<PostsGroupByYear> {
     yearMap.get(year)?.push(post)
   })
 
-  // Sort posts within each year
   yearMap.forEach((yearPosts) => {
     yearPosts.sort((a: Post, b: Post) => {
       const aDate = a.data.published
@@ -66,9 +69,23 @@ export async function getPostsByYear(): Promise<PostsGroupByYear> {
   return new Map([...yearMap.entries()].sort((a, b) => b[0] - a[0]))
 }
 
-// Group posts by tags
-export async function sortPostsByTags() {
-  const posts = await getPosts()
+// Get all tags
+export async function getAllTags(lang?: string) {
+  const posts = await getPosts(lang)
+  const tags = new Set<string>()
+
+  posts.forEach((post: Post) => {
+    post.data.tags?.forEach((tag: string) =>
+      tags.add(tag),
+    )
+  })
+
+  return Array.from(tags)
+}
+
+// Get posts group by each tag
+export async function getPostsGroupByTags(lang?: string) {
+  const posts = await getRegularPosts(lang)
   const tagMap = new Map<string, Post[]>()
 
   posts.forEach((post: Post) => {
@@ -85,28 +102,10 @@ export async function sortPostsByTags() {
   return tagMap
 }
 
-// Get posts by specific tag
-export async function getPostsByTag(tag: string) {
-  const posts = await getPosts()
-
+// Get all posts by one tag
+export async function getPostsByTag(tag: string, lang?: string) {
+  const posts = await getRegularPosts(lang)
   return posts.filter((post: Post) =>
     post.data.tags?.includes(tag),
   )
 }
-
-// Get all tags list
-export async function getAllTags() {
-  const posts = await getCollection(
-    'posts',
-    ({ data }: Post) => import.meta.env.DEV || !data.draft,
-  )
-  const tags = new Set<string>()
-
-  posts.forEach((post: Post) => {
-    post.data.tags?.forEach((tag: string) =>
-      tags.add(tag),
-    )
-  })
-
-  return Array.from(tags)
-}