refactor(blog): vendor shared libs and add tags sidebar group

Copy authors, content, and tags helpers from starlight-blog into a
local libs directory so they can be patched. Add a localized tags
sidebar group to the blog middleware and remove the BlogI18nControls
component from the blog listing page.

Co-Authored-By: Hagicode <noreply@hagicode.com>
Signed-off-by: newbe36524 <newbe36524@qq.com>

Author: newbe36524

src/integrations/starlight-blog-no-tags/libs/authors.ts

@@ -0,0 +1,110 @@
+import type { GetStaticPathsResult } from 'astro'
+import { slug } from 'github-slugger'
+import starlightConfig from 'virtual:starlight/user-config'
+import config from 'virtual:starlight-blog/config'
+
+import type { StarlightBlogAuthor } from '../../../../node_modules/starlight-blog/schema'
+import { DefaultLocale, type Locale } from '../../../../node_modules/starlight-blog/libs/i18n.ts'
+import { getPathWithLocale } from '../../../../node_modules/starlight-blog/libs/page.ts'
+import { getBlogEntries, type StarlightBlogEntry } from './content'
+
+export async function getAllAuthors(locale: Locale): Promise<StarlightBlogEntryAuthors> {
+  const entries = await getBlogEntries(locale)
+  const entryAuthors: StarlightBlogEntryAuthors = new Map()
+
+  for (const entry of entries) {
+    for (const author of getEntryAuthors(entry)) {
+      const infos = entryAuthors.get(author.name) ?? { entries: [], author: { ...author, slug: slug(author.name) } }
+
+      infos.entries.push(entry)
+
+      entryAuthors.set(author.name, infos)
+    }
+  }
+
+  return entryAuthors
+}
+
+export async function getAuthorsStaticPaths() {
+  const paths = []
+
+  if (starlightConfig.isMultilingual) {
+    for (const localeKey of Object.keys(starlightConfig.locales)) {
+      const locale = localeKey === 'root' ? undefined : localeKey
+
+      const entryAuthors = await getAllAuthors(locale)
+
+      for (const [, { author, entries }] of entryAuthors.entries()) {
+        paths.push(getAuthorsStaticPath(entries, author, locale))
+      }
+    }
+  } else {
+    const entryAuthors = await getAllAuthors(DefaultLocale)
+
+    for (const [, { author, entries }] of entryAuthors.entries()) {
+      paths.push(getAuthorsStaticPath(entries, author, DefaultLocale))
+    }
+  }
+
+  return paths satisfies GetStaticPathsResult
+}
+
+export function getEntryAuthors(entry: StarlightBlogEntry): StarlightBlogAuthor[] {
+  const authors: StarlightBlogAuthor[] = []
+
+  if (!entry.data.authors) {
+    authors.push(...Object.values(config.authors))
+  } else if (typeof entry.data.authors === 'string') {
+    authors.push(getAuthorFromConfig(entry.data.authors))
+  } else if (Array.isArray(entry.data.authors)) {
+    for (const author of entry.data.authors) {
+      if (typeof author === 'string') {
+        authors.push(getAuthorFromConfig(author))
+      } else {
+        authors.push(author)
+      }
+    }
+  } else {
+    authors.push(entry.data.authors)
+  }
+
+  return authors
+}
+
+function getAuthorFromConfig(id: string): StarlightBlogAuthor {
+  const author = config.authors[id]
+
+  if (!author) {
+    throw new Error(`Author '${id}' not found in the blog configuration.`)
+  }
+
+  return author
+}
+
+function getAuthorsStaticPath(entries: StarlightBlogEntry[], author: StarlightBlogEntryAuthor, locale: Locale) {
+  return {
+    params: {
+      prefix: getPathWithLocale(config.prefix, locale),
+      author: author.slug,
+    },
+    props: {
+      author,
+      entries,
+      locale,
+    },
+  }
+}
+
+type StarlightBlogEntryAuthorSlug = string
+
+interface StarlightBlogEntryAuthor extends StarlightBlogAuthor {
+  slug: StarlightBlogEntryAuthorSlug
+}
+
+type StarlightBlogEntryAuthors = Map<
+  StarlightBlogEntryAuthorSlug,
+  {
+    entries: StarlightBlogEntry[]
+    author: StarlightBlogEntryAuthor
+  }
+>

src/integrations/starlight-blog-no-tags/libs/content.ts

@@ -0,0 +1,224 @@
+import type { GetStaticPathsResult } from 'astro'
+import { type CollectionEntry, getCollection, getEntry, render } from 'astro:content'
+import starlightConfig from 'virtual:starlight/user-config'
+import config from 'virtual:starlight-blog/config'
+
+import { DefaultLocale, type Locale } from '../../../../node_modules/starlight-blog/libs/i18n.ts'
+import { getRelativeUrl, getRelativeBlogUrl, getPathWithLocale } from '../../../../node_modules/starlight-blog/libs/page.ts'
+import { stripLeadingSlash, stripTrailingSlash } from '../../../../node_modules/starlight-blog/libs/path.ts'
+
+const blogEntriesPerLocale = new Map<Locale, StarlightBlogEntry[]>()
+
+export async function getBlogStaticPaths() {
+  const paths = []
+
+  if (starlightConfig.isMultilingual) {
+    for (const localeKey of Object.keys(starlightConfig.locales)) {
+      const locale = localeKey === 'root' ? undefined : localeKey
+
+      const entries = await getBlogEntries(locale)
+      const pages = getPaginatedBlogEntries(entries)
+
+      for (const [index, entries] of pages.entries()) {
+        paths.push(getBlogStaticPath(pages, entries, index, locale))
+      }
+    }
+  } else {
+    const entries = await getBlogEntries(DefaultLocale)
+    const pages = getPaginatedBlogEntries(entries)
+
+    for (const [index, entries] of pages.entries()) {
+      paths.push(getBlogStaticPath(pages, entries, index, DefaultLocale))
+    }
+  }
+
+  return paths satisfies GetStaticPathsResult
+}
+
+export async function getSidebarBlogEntries(locale: Locale) {
+  const entries = await getBlogEntries(locale)
+
+  const featured: StarlightBlogEntry[] = []
+  const recent: StarlightBlogEntry[] = []
+
+  for (const entry of entries) {
+    if (entry.data.featured) {
+      featured.push(entry)
+    } else {
+      recent.push(entry)
+    }
+  }
+
+  return { featured, recent: recent.slice(0, config.recentPostCount) }
+}
+
+export async function getBlogEntry(slug: string, locale: Locale): Promise<StarlightBlogEntryPaginated> {
+  const entries = await getBlogEntries(locale)
+
+  const entryIndex = entries.findIndex((entry) => {
+    if (entry.id === stripLeadingSlash(stripTrailingSlash(slug))) return true
+    if (locale) return entry.id === stripLeadingSlash(stripTrailingSlash(getPathWithLocale(slug, undefined)))
+    return false
+  })
+  const entry = entries[entryIndex]
+
+  if (!entry) {
+    throw new Error(`Blog post with slug '${slug}' not found.`)
+  }
+
+  validateBlogEntry(entry)
+
+  const prevEntry = entries[entryIndex - 1]
+  const prevLink = prevEntry
+    ? { href: getRelativeUrl(`/${getPathWithLocale(prevEntry.id, locale)}`), label: prevEntry.data.title }
+    : undefined
+
+  const nextEntry = entries[entryIndex + 1]
+  const nextLink = nextEntry
+    ? { href: getRelativeUrl(`/${getPathWithLocale(nextEntry.id, locale)}`), label: nextEntry.data.title }
+    : undefined
+
+  return {
+    entry,
+    nextLink: config.prevNextLinksOrder === 'reverse-chronological' ? nextLink : prevLink,
+    prevLink: config.prevNextLinksOrder === 'reverse-chronological' ? prevLink : nextLink,
+  }
+}
+
+function isDefaultLocaleBlogEntry(entry: CollectionEntry<'docs'>) {
+  return entry.id.startsWith(`${config.prefix}/`) && entry.id !== `${config.prefix}/index`
+}
+
+export async function getBlogEntries(locale: Locale): Promise<StarlightBlogEntry[]> {
+  if (blogEntriesPerLocale.has(locale)) {
+    return blogEntriesPerLocale.get(locale) as StarlightBlogEntry[]
+  }
+
+  const docEntries = await getCollection('docs')
+  const blogEntries: StarlightEntry[] = []
+
+  for (const entry of docEntries) {
+    if (import.meta.env.MODE === 'production' && entry.data.draft === true) continue
+    if (!isDefaultLocaleBlogEntry(entry)) continue
+
+    if (locale === DefaultLocale) {
+      blogEntries.push(entry)
+      continue
+    }
+
+    const localizedEntryId = getPathWithLocale(entry.id, locale)
+
+    try {
+      const localizedEntry = await getEntry('docs', localizedEntryId)
+      if (!localizedEntry) throw new Error('Unavailable localized entry.')
+      if (localizedEntry.data.draft === true) throw new Error('Draft localized entry.')
+      blogEntries.push(localizedEntry)
+    } catch {
+      blogEntries.push(entry)
+    }
+  }
+
+  validateBlogEntries(blogEntries)
+
+  blogEntries.sort((a, b) => {
+    return b.data.date.getTime() - a.data.date.getTime() || a.data.title.localeCompare(b.data.title)
+  })
+
+  blogEntriesPerLocale.set(locale, blogEntries)
+
+  return blogEntries
+}
+
+export async function getBlogEntryExcerpt(entry: StarlightBlogEntry) {
+  if (entry.data.excerpt) {
+    return entry.data.excerpt
+  }
+
+  const { Content } = await render(entry)
+
+  return Content
+}
+
+function getBlogStaticPath(
+  pages: StarlightBlogEntry[][],
+  entries: StarlightBlogEntry[],
+  index: number,
+  locale: Locale,
+) {
+  const prevPage = index === 0 ? undefined : pages.at(index - 1)
+  const prevLink = prevPage ? { href: getRelativeBlogUrl(index === 1 ? '/' : `/${index}`, locale) } : undefined
+
+  const nextPage = pages.at(index + 1)
+  const nextLink = nextPage ? { href: getRelativeBlogUrl(`/${index + 2}`, locale) } : undefined
+
+  return {
+    params: {
+      page: index === 0 ? undefined : `${index + 1}`,
+      prefix: getPathWithLocale(config.prefix, locale),
+    },
+    props: {
+      entries,
+      locale,
+      nextLink: config.prevNextLinksOrder === 'reverse-chronological' ? nextLink : prevLink,
+      prevLink: config.prevNextLinksOrder === 'reverse-chronological' ? prevLink : nextLink,
+    } satisfies StarlightBlogStaticProps,
+  }
+}
+
+function getPaginatedBlogEntries(entries: StarlightBlogEntry[]): StarlightBlogEntry[][] {
+  const pages: StarlightBlogEntry[][] = []
+
+  for (const entry of entries) {
+    const lastPage = pages.at(-1)
+
+    if (!lastPage || lastPage.length === config.postCount) {
+      pages.push([entry])
+    } else {
+      lastPage.push(entry)
+    }
+  }
+
+  if (pages.length === 0) {
+    pages.push([])
+  }
+
+  return pages
+}
+
+function validateBlogEntries(entries: StarlightEntry[]): asserts entries is StarlightBlogEntry[] {
+  for (const entry of entries) {
+    validateBlogEntry(entry)
+  }
+}
+
+function validateBlogEntry(entry: StarlightEntry): asserts entry is StarlightBlogEntry {
+  if (entry.data.date === undefined) {
+    throw new Error(`Missing date for blog entry '${entry.id}'.`)
+  }
+}
+
+type StarlightEntry = CollectionEntry<'docs'>
+
+export type StarlightBlogEntry = StarlightEntry & {
+  data: {
+    date: Date
+  }
+}
+
+export interface StarlightBlogLink {
+  href: string
+  label?: string
+}
+
+export interface StarlightBlogEntryPaginated {
+  entry: StarlightBlogEntry
+  nextLink: StarlightBlogLink | undefined
+  prevLink: StarlightBlogLink | undefined
+}
+
+interface StarlightBlogStaticProps {
+  entries: StarlightBlogEntry[]
+  locale: Locale
+  nextLink: StarlightBlogLink | undefined
+  prevLink: StarlightBlogLink | undefined
+}