retypeset-odyssey 0.1.0

package/src/utils/description.ts

@@ -0,0 +1,147 @@
+import type { CollectionEntry } from 'astro:content'
+import type { Language } from '@/i18n/config'
+import MarkdownIt from 'markdown-it'
+import { defaultLocale } from '@/config'
+
+type ExcerptScene = 'list' | 'meta' | 'og' | 'feed'
+
+const markdownParser = new MarkdownIt()
+const excerptLengths: Record<ExcerptScene, { cjk: number, other: number }> = {
+  list: {
+    cjk: 120,
+    other: 240,
+  },
+  meta: {
+    cjk: 120,
+    other: 240,
+  },
+  og: {
+    cjk: 70,
+    other: 140,
+  },
+  feed: {
+    cjk: 70,
+    other: 140,
+  },
+}
+
+const htmlEntityMap: Record<string, string> = {
+  '&lt;': '<',
+  '&gt;': '>',
+  '&amp;': '&',
+  '&quot;': '"',
+  '&apos;': '\'',
+  '&nbsp;': ' ',
+}
+
+// Cleans text by removing HTML tags and normalizing whitespace
+function cleanTextContent(text: string): string {
+  // Remove HTML tags
+  let cleanText = text.replace(/<[^>]*>/g, '')
+
+  // Decode HTML entities
+  Object.entries(htmlEntityMap).forEach(([entity, char]) => {
+    cleanText = cleanText.replace(new RegExp(entity, 'g'), char)
+  })
+
+  // Normalize whitespace
+  cleanText = cleanText.replace(/\s+/g, ' ')
+
+  // Normalize CJK punctuation spacing
+  cleanText = cleanText.replace(/([。？！："」』])\s+/g, '$1')
+
+  return cleanText.trim()
+}
+
+// Creates a clean text excerpt with length limits by language and scene
+function getExcerpt(text: string, lang: Language, scene: ExcerptScene): string {
+  const isCJK = (lang: Language) => ['zh', 'zh-tw', 'ja', 'ko'].includes(lang)
+  const length = isCJK(lang)
+    ? excerptLengths[scene].cjk
+    : excerptLengths[scene].other
+
+  const cleanText = cleanTextContent(text)
+  const excerpt = cleanText.slice(0, length).trim()
+
+  // Remove trailing punctuation and add ellipsis
+  if (cleanText.length > length) {
+    return `${excerpt.replace(/\p{P}+$/u, '')}...`
+  }
+
+  return excerpt
+}
+
+// Generates post description from existing description or content
+type DescribableEntry = {
+  data: {
+    description?: string
+    lang?: string
+  }
+  body?: string
+}
+
+function getEntryDescription(
+  entry: DescribableEntry,
+  scene: ExcerptScene,
+): string {
+  const lang = (entry.data.lang || defaultLocale) as Language
+
+  if (entry.data.description) {
+    // Only truncate for og scene, return full description for other scenes
+    return scene === 'og'
+      ? getExcerpt(entry.data.description, lang, scene)
+      : entry.data.description
+  }
+
+  const rawContent = entry.body || ''
+
+  // Check for <!-- more --> marker (Hexo-style excerpt boundary)
+  const moreMarkerRegex = /<!--\s*more\s*-->/i
+  const moreMatch = rawContent.match(moreMarkerRegex)
+  const hasMoreMarker = moreMatch && moreMatch.index !== undefined
+
+  // Get content to process (before <!-- more --> if exists)
+  let contentToProcess = rawContent
+  if (hasMoreMarker) {
+    contentToProcess = rawContent.substring(0, moreMatch.index)
+  }
+
+  const cleanContent = contentToProcess
+    .replace(/<!--[\s\S]*?-->/g, '') // Remove remaining HTML comments
+    .replace(/```[\s\S]*?```/g, '') // Remove code blocks
+    .replace(/^\s*#{1,6}\s+\S.*$/gm, '') // Remove Markdown headings
+    .replace(/^\s*::.*$/gm, '') // Remove directive containers
+    .replace(/^\s*>\s*\[!.*\]$/gm, '') // Remove GitHub admonition markers
+    .replace(/\n{2,}/g, '\n\n') // Normalize newlines
+
+  const renderedContent = markdownParser.render(cleanContent)
+
+  // For 'list' scene with <!-- more --> marker, return full content without truncation
+  if (scene === 'list' && hasMoreMarker) {
+    return cleanTextContent(renderedContent)
+  }
+
+  // Otherwise, apply truncation
+  return getExcerpt(renderedContent, lang, scene)
+}
+
+export function getPostDescription(
+  post: CollectionEntry<'posts'>,
+  scene: ExcerptScene,
+): string {
+  return getEntryDescription(post, scene)
+}
+
+export function getNoteDescription(
+  note: CollectionEntry<'notes'>,
+  scene: ExcerptScene,
+): string {
+  return getEntryDescription(note, scene)
+}
+
+export function getJournalDescription(
+  journal: CollectionEntry<'journals'>,
+  scene: ExcerptScene,
+): string {
+  return getEntryDescription(journal, scene)
+}

package/src/utils/dynamic-collections.ts

@@ -0,0 +1,155 @@
+/**
+ * Generic accessors for dynamically-registered content collections.
+ *
+ * Every folder discovered under `content/` (excluding built-ins and
+ * underscore-prefixed folders) is registered with the same schema as `posts`.
+ * Templates in `src/pages/_dynamic/` use these helpers to fetch and group
+ * entries the same way the posts/notes/journals utilities do — minus the
+ * tag/category bookkeeping that only makes sense for posts.
+ */
+
+import type { CollectionEntry } from 'astro:content'
+import type { Language } from '@/i18n/config'
+import { getCollection, render } from 'astro:content'
+import { allLocales, defaultLocale } from '@/config'
+
+// All dynamic collections share the same loader+schema as `posts`, so a
+// CollectionEntry<'posts'> is structurally identical. Cast through the
+// `posts` slot so the rest of the codebase's types still line up.
+export type DynamicEntry = CollectionEntry<'posts'>
+
+export interface DynamicEntryWithMeta extends DynamicEntry {
+  remarkPluginFrontmatter: { minutes: number }
+}
+
+export interface DynamicGroup {
+  baseId: string
+  slug: string
+  supportedLangs: Language[]
+  byLang: Partial<Record<Language, DynamicEntry>>
+}
+
+function slugifyPathSegment(input: string): string {
+  return input
+    .normalize('NFKC')
+    .trim()
+    .toLowerCase()
+    .replace(/[\s_]+/g, '-')
+    .replace(/[^\p{Letter}\p{Number}]+/gu, '-')
+    .replace(/-+/g, '-')
+    .replace(/^-|-$/g, '')
+}
+
+function getBaseId(entry: DynamicEntry): string {
+  const id = entry.id.trim()
+  for (const lang of allLocales) {
+    const suffix = `.${lang}`
+    if (id.endsWith(suffix))
+      return id.slice(0, -suffix.length)
+  }
+  return id
+}
+
+/**
+ * Read entries from a dynamic collection. Returns `[]` if the collection
+ * is not registered (no folder, or `enabled: false`) instead of crashing —
+ * this matches the behaviour of the built-in note/journal utilities.
+ */
+async function safeGetCollection(name: string): Promise<DynamicEntry[]> {
+  try {
+    const entries = await getCollection(
+      name as 'posts',
+      ({ data }: DynamicEntry) => !data.draft,
+    )
+    return entries
+  }
+  catch (error) {
+    const message = error instanceof Error ? error.message : String(error)
+    if (
+      message.includes(`The collection "${name}" does not exist`)
+      || message.includes(`The collection "${name}" is empty`)
+    ) {
+      return []
+    }
+    throw error
+  }
+}
+
+export async function getDynamicGroups(collection: string): Promise<DynamicGroup[]> {
+  const entries = await safeGetCollection(collection)
+
+  const buckets = new Map<string, DynamicEntry[]>()
+  for (const entry of entries) {
+    const baseId = getBaseId(entry)
+    const list = buckets.get(baseId) ?? []
+    list.push(entry)
+    buckets.set(baseId, list)
+  }
+
+  const slugToBaseId = new Map<string, string>()
+  const results: DynamicGroup[] = []
+
+  for (const [baseId, members] of buckets) {
+    const slug = slugifyPathSegment(baseId) || baseId
+    const existing = slugToBaseId.get(slug)
+    if (existing && existing !== baseId) {
+      throw new Error(
+        `Duplicate slug "${slug}" in collection "${collection}" `
+        + `from "${existing}" and "${baseId}"`,
+      )
+    }
+    slugToBaseId.set(slug, baseId)
+
+    const baseEntry = members.find(e => !e.data.lang)
+    const zhEntry = members.find(e => e.data.lang === 'zh')
+    const enEntry = members.find(e => e.data.lang === 'en')
+    const jaEntry = members.find(e => e.data.lang === 'ja')
+
+    // Best-effort base-language inference, mirroring the post/note logic:
+    // a sole base file alongside an explicit `zh` translation is taken as en.
+    const inferredEnFromBase = !enEntry && !!zhEntry ? baseEntry : undefined
+    const inferredZhFromBase = !zhEntry ? baseEntry : undefined
+
+    const byLang: DynamicGroup['byLang'] = {
+      zh: zhEntry ?? inferredZhFromBase,
+      en: enEntry ?? inferredEnFromBase,
+      ja: jaEntry,
+    }
+
+    const supportedLangs = allLocales.filter(lang => byLang[lang])
+
+    results.push({ baseId, slug, supportedLangs, byLang })
+  }
+
+  return results
+}
+
+export function getDynamicSlug(entry: DynamicEntry): string {
+  return slugifyPathSegment(getBaseId(entry)) || getBaseId(entry)
+}
+
+async function attachMeta(entry: DynamicEntry): Promise<DynamicEntryWithMeta> {
+  const { remarkPluginFrontmatter } = await render(entry)
+  return {
+    ...entry,
+    remarkPluginFrontmatter: remarkPluginFrontmatter as { minutes: number },
+  }
+}
+
+export async function getDynamicEntries(
+  collection: string,
+  lang?: Language,
+): Promise<DynamicEntryWithMeta[]> {
+  const currentLang = lang && allLocales.includes(lang) ? lang : defaultLocale
+  const groups = await getDynamicGroups(collection)
+  const selected = groups
+    .map(group => group.byLang[currentLang])
+    .filter(Boolean) as DynamicEntry[]
+
+  const enhanced = await Promise.all(selected.map(attachMeta))
+
+  const sortKey = (entry: DynamicEntry) =>
+    (entry.data.updated ?? entry.data.published).valueOf()
+
+  return enhanced.sort((a, b) => sortKey(b) - sortKey(a))
+}

package/src/utils/feed.ts

@@ -0,0 +1,238 @@
+import type { APIContext, ImageMetadata } from 'astro'
+import type { Language } from '@/i18n/config'
+import { getImage } from 'astro:assets'
+import { Feed } from 'feed'
+import MarkdownIt from 'markdown-it'
+import { parse } from 'node-html-parser'
+import sanitizeHtml from 'sanitize-html'
+import { base, defaultLocale, themeConfig } from '@/config'
+import { getPostPath } from '@/i18n/path'
+import { ui } from '@/i18n/ui'
+import { memoize } from '@/utils/cache'
+import { getPosts, getPostSlug } from '@/utils/content'
+import { getPostDescription } from '@/utils/description'
+
+const markdownParser = new MarkdownIt()
+const { title, description, i18nTitle, url, author } = themeConfig.site
+const { follow } = themeConfig.seo ?? {}
+
+// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
+// Dynamically import all images from /content/posts
+const imagesGlob = import.meta.glob<{ default: ImageMetadata }>(
+  '/content/posts/**/*.{jpeg,jpg,png,gif,webp}',
+)
+
+/**
+ * Converts relative image paths to absolute URLs
+ *
+ * @param srcPath - Relative image path from markdown content
+ * @param baseUrl - Site base URL
+ * @returns Optimized image URL or null if processing fails
+ */
+async function _getAbsoluteImageUrl(srcPath: string, baseUrl: string) {
+  // Remove relative path prefixes (../ and ./) from image source path
+  const prefixRemoved = srcPath.replace(/^(?:\.\.\/)+|^\.\//, '')
+  const absolutePath = `/content/posts/${prefixRemoved}`
+  const imageImporter = imagesGlob[absolutePath]
+
+  if (!imageImporter) {
+    return null
+  }
+
+  // Import image module and extract its metadata
+  const imageMetadata = await imageImporter()
+    .then(importedModule => importedModule.default)
+    .catch((error) => {
+      console.warn(`Failed to import image: ${absolutePath}`, error)
+      return null
+    })
+
+  if (!imageMetadata) {
+    return null
+  }
+
+  // Create optimized image from metadata
+  const optimizedImage = await getImage({ src: imageMetadata })
+  return new URL(optimizedImage.src, baseUrl).toString()
+}
+
+// Export memoized version
+const getAbsoluteImageUrl = memoize(_getAbsoluteImageUrl)
+
+/**
+ * Fix relative image paths in HTML content
+ *
+ * @param htmlContent HTML content string
+ * @param baseUrl Base URL of the site
+ * @returns Processed HTML string with all image paths converted to absolute URLs
+ */
+async function fixRelativeImagePaths(htmlContent: string, baseUrl: string): Promise<string> {
+  const htmlDoc = parse(htmlContent)
+  const images = htmlDoc.getElementsByTagName('img')
+  const imagePromises = []
+
+  for (const img of images) {
+    const src = img.getAttribute('src')
+    if (!src) {
+      continue
+    }
+
+    imagePromises.push((async () => {
+      try {
+        // Skip absolute URLs and unsupported sources
+        if (!src.startsWith('./') && !src.startsWith('../') && !src.startsWith('_images/')) {
+          return
+        }
+
+        // Process images from content/posts
+        const absoluteImageUrl = await getAbsoluteImageUrl(src, baseUrl)
+        if (absoluteImageUrl) {
+          img.setAttribute('src', absoluteImageUrl)
+        }
+      }
+      catch (error) {
+        console.warn(`Failed to convert relative image path to absolute URL: ${src}`, error)
+      }
+    })())
+  }
+
+  await Promise.all(imagePromises)
+
+  return htmlDoc.toString()
+}
+
+/**
+ * >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
+ * Generate a feed object supporting both RSS and Atom formats
+ *
+ * @param options Feed generation options
+ * @param options.lang Optional language code
+ * @returns A Feed instance ready for RSS or Atom output
+ */
+export async function generateFeed({ lang }: { lang?: Language } = {}) {
+  const currentUI = ui[lang as keyof typeof ui] ?? ui[defaultLocale as keyof typeof ui] ?? {}
+  const siteURL = lang ? `${url}${base}/${lang}` : `${url}${base}/`
+
+  // Create Feed instance
+  const feed = new Feed({
+    title: i18nTitle ? currentUI.title : title,
+    description: i18nTitle ? currentUI.description : description,
+    id: siteURL,
+    link: siteURL,
+    language: lang ?? themeConfig.global.locale,
+    copyright: `Copyright © ${new Date().getFullYear()} ${author}`,
+    updated: new Date(),
+    generator: 'Astro-Theme-Retypeset with Feed for Node.js',
+
+    feedLinks: {
+      rss: new URL(lang ? `${base}/${lang}/rss.xml` : `${base}/rss.xml`, url).toString(),
+      atom: new URL(lang ? `${base}/${lang}/atom.xml` : `${base}/atom.xml`, url).toString(),
+    },
+
+    author: {
+      name: author,
+      link: `${url}${base}/`,
+    },
+  })
+
+  // Language-aware selection (includes inferred base-language posts)
+  const recentPosts = (await getPosts(lang))
+    .slice(0, 25)
+
+  // Add posts to feed
+  for (const post of recentPosts) {
+    const slug = getPostSlug(post)
+    const link = new URL(
+      getPostPath(slug, (lang ?? defaultLocale) as Language),
+      url,
+    ).toString()
+
+    // Optimize content processing
+    const postContent = post.body
+      ? sanitizeHtml(
+          await fixRelativeImagePaths(
+            // Remove HTML comments before rendering markdown
+            markdownParser.render(post.body.replace(/<!--[\s\S]*?-->/g, '')),
+            `${url}${base}/`,
+          ),
+          {
+            // Allow <img> tags in feed content
+            allowedTags: sanitizeHtml.defaults.allowedTags.concat(['img']),
+          },
+        )
+      : ''
+
+    // publishDate -> Atom:<published>, RSS:<pubDate>
+    const publishDate = new Date(post.data.published)
+    // updateDate -> Atom:<updated>, RSS has no update tag
+    const updateDate = post.data.updated ? new Date(post.data.updated) : publishDate
+
+    feed.addItem({
+      title: post.data.title,
+      id: link,
+      link,
+      description: getPostDescription(post, 'feed'),
+      content: postContent,
+      author: [{
+        name: author,
+        link: `${url}${base}/`,
+      }],
+      published: publishDate,
+      date: updateDate,
+    })
+  }
+
+  // Add follow verification if available
+  if (follow?.feedID && follow?.userID) {
+    feed.addExtension({
+      name: 'follow_challenge',
+      objects: {
+        feedId: follow.feedID,
+        userId: follow.userID,
+      },
+    })
+  }
+
+  return feed
+}
+
+// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
+// Generate RSS 2.0 format feed
+export async function generateRSS(context: APIContext) {
+  const feed = await generateFeed({
+    lang: context.params?.lang as Language | undefined,
+  })
+
+  // Add XSLT stylesheet to RSS feed
+  let rssXml = feed.rss2()
+  rssXml = rssXml.replace(
+    '<?xml version="1.0" encoding="utf-8"?>',
+    `<?xml version="1.0" encoding="utf-8"?>\n<?xml-stylesheet href="${base}/feeds/rss-style.xsl" type="text/xsl"?>`,
+  )
+
+  return new Response(rssXml, {
+    headers: {
+      'Content-Type': 'application/rss+xml; charset=utf-8',
+    },
+  })
+}
+
+// Generate Atom 1.0 format feed
+export async function generateAtom(context: APIContext) {
+  const feed = await generateFeed({
+    lang: context.params?.lang as Language | undefined,
+  })
+
+  // Add XSLT stylesheet to Atom feed
+  let atomXml = feed.atom1()
+  atomXml = atomXml.replace(
+    '<?xml version="1.0" encoding="utf-8"?>',
+    `<?xml version="1.0" encoding="utf-8"?>\n<?xml-stylesheet href="${base}/feeds/atom-style.xsl" type="text/xsl"?>`,
+  )
+
+  return new Response(atomXml, {
+    headers: {
+      'Content-Type': 'application/atom+xml; charset=utf-8',
+    },
+  })
+}

package/src/utils/page.ts

@@ -0,0 +1,107 @@
+import { base, moreLocales } from '@/config'
+import { getLangFromPath } from '@/i18n/lang'
+import { getLocalizedPath } from '@/i18n/path'
+
+function stripHtmlExtension(path: string): string {
+  return path.endsWith('.html') ? path.slice(0, -'.html'.length) : path
+}
+
+// Determine if the path matches a specific page type
+function matchPageType(path: string, prefix: string = '') {
+  // Remove base path if configured
+  const pathWithoutBase = base && path.startsWith(base)
+    ? path.slice(base.length)
+    : path
+
+  // Remove leading and trailing slashes from the path
+  const normalizedPath = stripHtmlExtension(pathWithoutBase.replace(/^\/|\/$/g, ''))
+
+  // Homepage check: matches root path ('') or language code ('en')
+  //
+  // Astro 6 with `build.format: 'file'` + `trailingSlash: 'never'` writes
+  // `dist/index.html` and reports `Astro.url.pathname === '/index.html'`
+  // for the homepage (Astro 5 used '/'). Normalising past the `.html` strip
+  // leaves us with 'index' or '<lang>/index' for the localised variants;
+  // treat those as homepage too so excerpt rendering keeps working.
+  if (prefix === '') {
+    if (normalizedPath === '' || normalizedPath === 'index') {
+      return true
+    }
+
+    const locales = moreLocales as readonly string[]
+    if (locales.includes(normalizedPath)) {
+      return true
+    }
+    if (locales.some(lang => normalizedPath === `${lang}/index`)) {
+      return true
+    }
+
+    // Pagination pages: /2, /3 ... and /en/2, /ja/3 ...
+    if (/^\d+$/.test(normalizedPath)) {
+      return true
+    }
+
+    return locales.some((lang) => {
+      if (!normalizedPath.startsWith(`${lang}/`)) {
+        return false
+      }
+      const rest = normalizedPath.slice(lang.length + 1)
+      return /^\d+$/.test(rest)
+    })
+  }
+
+  // Ensure strict segment boundary matching to prevent partial matches
+  const startsWithSegment = (target: string, segment: string) =>
+    target === segment || target.startsWith(`${segment}/`)
+
+  // Match both default language paths and localized paths
+  return startsWithSegment(normalizedPath, prefix)
+    || moreLocales.some(lang => startsWithSegment(normalizedPath, `${lang}/${prefix}`))
+}
+
+export function isHomePage(path: string) {
+  return matchPageType(path)
+}
+
+export function isPostPage(path: string) {
+  return matchPageType(path, 'posts')
+}
+
+export function isNotePage(path: string) {
+  return matchPageType(path, 'notes')
+}
+
+export function isJournalPage(path: string) {
+  return matchPageType(path, 'journals')
+}
+
+export function isTagPage(path: string) {
+  return matchPageType(path, 'tags')
+}
+
+export function isAboutPage(path: string) {
+  return matchPageType(path, 'about')
+}
+
+// Returns page context with language, page types and localization helper
+export function getPageInfo(path: string) {
+  const currentLang = getLangFromPath(path)
+  const isHome = isHomePage(path)
+  const isPost = isPostPage(path)
+  const isNote = isNotePage(path)
+  const isJournal = isJournalPage(path)
+  const isTag = isTagPage(path)
+  const isAbout = isAboutPage(path)
+
+  return {
+    currentLang,
+    isHome,
+    isPost,
+    isNote,
+    isJournal,
+    isTag,
+    isAbout,
+    getLocalizedPath: (targetPath: string) =>
+      getLocalizedPath(targetPath, currentLang),
+  }
+}

package/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "extends": "astro/tsconfigs/strict",
+  "compilerOptions": {
+    "lib": ["esnext", "dom"],
+    "baseUrl": ".",
+    "paths": {
+      "@/*": ["src/*"]
+    },
+    "allowJs": true
+  },
+  "include": [".astro/types.d.ts", "**/*"],
+  "exclude": ["dist"]
+}