@jaamd/jaad 0.0.0-stage → 0.11.0

package/src/layouts/Docs.astro

@@ -0,0 +1,168 @@
+---
+import type { DocsEntry, DocsHeadings } from '../@types/docs.ts'
+import type { DocsFrameProps } from '../advanced.ts'
+import type { DocsNavigation } from '../navigation.ts'
+import { ClientRouter } from 'astro:transitions'
+import config from 'virtual:jaad/config'
+import DocsFrame from 'virtual:jaad/docs-frame'
+import { getLocaleAlternates } from '../collection.ts'
+import DocsSidebarLeft from '../components/docs/DocsSidebarLeft.astro'
+import StructuredData from '../components/docs/StructuredData.astro'
+import TableOfContents from '../components/docs/TableOfContents.astro'
+import Footer from '../components/Footer.astro'
+import Head from '../components/Head.astro'
+import Header from '../components/Header.astro'
+import { DEFAULT_LOCALE, LOCALES } from '../docs-config.ts'
+import { docTitle, docTranslationKey, extractDescription, getCleanSlug, routedId } from '../utils/docs.ts'
+import '../../dist/jaad.css'
+import '../styles/docs.css'
+import '../styles/jaamd.css'
+import '@jaamd/jaamd/styles.css'
+import 'virtual:jaad/theme.css'
+import 'virtual:jaad/bridge.css'
+import 'virtual:jaad/user.css'
+import 'virtual:jaad/tailwind.css'
+
+interface Props {
+    title?: string
+    chapter?: string
+    entry?: DocsEntry
+    headings?: DocsHeadings[]
+    navigation: DocsNavigation
+}
+
+const { title, chapter, entry, headings = [], navigation } = Astro.props
+
+const pageTitle = title ? `${title} | ${config.title}` : config.title
+
+// The opening page gets no `title`; resolve it from the entry.
+const entryTitle = entry ? docTitle(entry) : (title ?? '')
+
+const pageDescription =
+    entry?.data.description ??
+    (entry ? extractDescription(entry.body || '', entryTitle) : null) ??
+    config.description ??
+    config.title
+
+const locale = entry?.locale ?? DEFAULT_LOCALE
+const language = LOCALES.find((known) => known.code === locale)?.tag ?? config.lang
+
+const switcherAlternates = await getLocaleAlternates(entry ? docTranslationKey(entry) : '')
+
+// x-default is a landing place, so it takes the fallback when this page has no
+// translation into the default locale.
+const xDefault = switcherAlternates.find((alternate) => alternate.locale.code === DEFAULT_LOCALE)?.href
+
+// hreflang describes translations of this page, not the switcher's fallbacks.
+const alternates = switcherAlternates
+    .filter((alternate) => alternate.translated)
+    .map((alternate) => ({
+        code: alternate.locale.code,
+        tag: alternate.locale.tag,
+        href: alternate.href,
+    }))
+
+const frameProps: DocsFrameProps = {
+    page: {
+        id: entry?.id ?? '',
+        slug: entry ? getCleanSlug(routedId(entry)) : '',
+        title: entryTitle,
+        chapter,
+        data: entry?.data ?? { draft: false, keywords: [] },
+    },
+    headings,
+    navigation,
+}
+---
+
+<!doctype html>
+<html lang={language} class={config.appearance === 'dark' ? 'dark' : undefined}>
+    <head>
+        <Head
+            title={pageTitle}
+            description={pageDescription}
+            keywords={entry?.data.keywords}
+            author={entry?.data.author}
+            image={entry?.data.ogImage}
+            modified={entry?.data.lastUpdated}
+            language={language}
+            {alternates}
+            {xDefault}
+        />
+        <StructuredData
+            title={entryTitle || config.title}
+            description={pageDescription}
+            chapter={chapter}
+            keywords={entry?.data.keywords}
+            author={entry?.data.author}
+            modified={entry?.data.lastUpdated}
+            {language}
+            {locale}
+        />
+        <ClientRouter />
+    </head>
+    <body data-docs class="jaad-body">
+        <DocsFrame {...frameProps}>
+            <Header slot="header" inDocs {locale} alternates={switcherAlternates} />
+            <DocsSidebarLeft slot="sidebar" sections={navigation.sections} {locale} />
+            <slot name="mobile-navigation" slot="mobile-navigation" />
+            <slot name="breadcrumbs" slot="breadcrumbs" />
+            <slot name="page-actions" slot="page-actions" />
+            <slot name="content" slot="content" />
+            <slot name="page-navigation" slot="page-navigation" />
+            <TableOfContents slot="table-of-contents" headings={headings} {locale} />
+            <Footer slot="footer" />
+        </DocsFrame>
+
+        <script>
+            import { navigate } from 'astro:transitions/client'
+
+            /** Identified by `rel`. */
+            function getPageLinks(): {
+                prev: HTMLAnchorElement | null
+                next: HTMLAnchorElement | null
+            } {
+                const nav = document.querySelector('nav[aria-label="Page navigation"]')
+                if (!nav) return { prev: null, next: null }
+                return {
+                    prev: nav.querySelector<HTMLAnchorElement>('a[rel~="prev"][href]'),
+                    next: nav.querySelector<HTMLAnchorElement>('a[rel~="next"][href]'),
+                }
+            }
+
+            /** A wide table or code block: the arrow keys should scroll it instead. */
+            function inHorizontallyScrollable(el: Element | null): boolean {
+                for (let node = el; node && node !== document.body;) {
+                    if (node instanceof HTMLElement) {
+                        const overflowX = getComputedStyle(node).overflowX
+                        if ((overflowX === 'auto' || overflowX === 'scroll') && node.scrollWidth > node.clientWidth)
+                            return true
+                    }
+                    node = node.parentElement
+                }
+                return false
+            }
+
+            function onKey(e: KeyboardEvent) {
+                // Leave modified chords alone, notably the browser's back/forward.
+                if (e.altKey || e.ctrlKey || e.metaKey || e.shiftKey) return
+                if (e.key !== 'ArrowLeft' && e.key !== 'ArrowRight') return
+
+                const active = document.activeElement as HTMLElement | null
+                const tag = active?.tagName
+                if (tag === 'INPUT' || tag === 'TEXTAREA' || tag === 'SELECT') return
+                if (active?.isContentEditable) return
+                if (inHorizontallyScrollable(active)) return
+
+                const { prev, next } = getPageLinks()
+                const target = e.key === 'ArrowLeft' ? prev : next
+                if (!target) return
+                e.preventDefault()
+                navigate(target.href)
+            }
+
+            // `document` survives View Transitions, and this module runs once.
+            document.addEventListener('keydown', onKey)
+        </script>
+    </body>
+</html>

package/src/layouts/Page.astro

@@ -0,0 +1,38 @@
+---
+import config from 'virtual:jaad/config'
+import Footer from '../components/Footer.astro'
+import Head from '../components/Head.astro'
+import Header from '../components/Header.astro'
+import '../../dist/jaad.css'
+import 'virtual:jaad/theme.css'
+import 'virtual:jaad/bridge.css'
+import 'virtual:jaad/user.css'
+import 'virtual:jaad/tailwind.css'
+
+interface Props {
+    title?: string
+    description?: string
+    bare?: boolean
+    /** Added to the body. */
+    class?: string
+}
+
+const { title, description, bare = false, class: className } = Astro.props
+
+const pageTitle = title ? `${title} | ${config.title}` : config.title
+const pageDescription = description ?? config.description ?? config.title
+---
+
+<!doctype html>
+<html lang={config.lang} class={config.appearance === 'dark' ? 'dark' : undefined}>
+    <head>
+        <Head title={pageTitle} description={pageDescription} />
+    </head>
+    <body class:list={['jaad-body', className]}>
+        <Header />
+        <main class={bare ? 'jaad-main-bare' : 'jaad-main'}>
+            <slot />
+        </main>
+        <Footer />
+    </body>
+</html>

package/src/locale-tree.ts

@@ -0,0 +1,51 @@
+import { existsSync, readdirSync } from 'node:fs'
+import { join } from 'node:path'
+import { isLocale } from './locales.ts'
+
+function hasMarkdown(dir: string): boolean {
+    return readdirSync(dir, { withFileTypes: true }).some((entry) =>
+        entry.isDirectory() ? hasMarkdown(join(dir, entry.name)) : entry.name.endsWith('.md'),
+    )
+}
+
+/** Locale directories under docs/, or none. Two mean the tree is organised by
+ *  language; one counts only when `lang` names it. */
+export function detectLocales(docsDir: string, lang: string): string[] {
+    if (!existsSync(docsDir)) return []
+
+    const candidates = readdirSync(docsDir, { withFileTypes: true })
+        .filter((entry) => entry.isDirectory() && isLocale(entry.name))
+        .map((entry) => entry.name.toLowerCase())
+        .toSorted()
+
+    const localised = candidates.length >= 2 || (candidates.length === 1 && candidates[0] === lang.toLowerCase())
+    if (!localised) return []
+
+    // An empty directory would reach the switcher and answer 404.
+    return candidates.filter((code) => hasMarkdown(join(docsDir, code)))
+}
+
+/** Once localised, every top-level entry is a locale and `lang` names one. */
+export function validateLocaleTree(docsDir: string, locales: string[], lang: string): void {
+    const issues: string[] = []
+
+    const strays = readdirSync(docsDir, { withFileTypes: true })
+        .filter((entry) => !(entry.isDirectory() && isLocale(entry.name)))
+        .map((entry) => entry.name)
+        .toSorted()
+
+    for (const stray of strays) {
+        issues.push(`docs/${stray} is not a locale, but ${locales.join(', ')} are`)
+    }
+
+    if (!locales.includes(lang.toLowerCase())) {
+        issues.push(`lang is "${lang}", which has no directory; found ${locales.join(', ')}`)
+    }
+
+    if (issues.length > 0) {
+        throw new Error(
+            `jaad: mixed documentation tree\n${issues.map((issue) => `  ${issue}`).join('\n')}\n` +
+                'Move every page under a locale directory, or set locales: false.',
+        )
+    }
+}

package/src/locales.ts

@@ -0,0 +1,191 @@
+import { ucfirst } from './utils/helpers.ts'
+
+/** ISO 639-1. A three-letter directory such as `api` is never a locale. */
+const LANGUAGES = new Set(
+    (
+        'aa ab ae af ak am an ar as av ay az ba be bg bi bm bn bo br bs ca ce ch co ' +
+        'cr cs cu cv cy da de dv dz ee el en eo es et eu fa ff fi fj fo fr fy ga gd ' +
+        'gl gn gu gv ha he hi ho hr ht hu hy hz ia id ie ig ii ik io is it iu ja jv ' +
+        'ka kg ki kj kk kl km kn ko kr ks ku kv kw ky la lb lg li ln lo lt lu lv mg ' +
+        'mh mi mk ml mn mr ms mt my na nb nd ne ng nl nn no nr nv ny oc oj om or os ' +
+        'pa pi pl ps pt qu rm rn ro ru rw sa sc sd se sg si sk sl sm sn so sq sr ss ' +
+        'st su sv sw ta te tg th ti tk tl tn to tr ts tt tw ty ug uk ur uz ve vi vo ' +
+        'wa wo xh yi yo za zh zu'
+    ).split(' '),
+)
+
+/** Region for a language that does not name one. Listed, never derived. */
+const LANGUAGE_REGION: Record<string, string> = {
+    af: 'ZA',
+    am: 'ET',
+    ar: 'SA',
+    az: 'AZ',
+    be: 'BY',
+    bg: 'BG',
+    bn: 'BD',
+    bs: 'BA',
+    ca: 'ES',
+    cs: 'CZ',
+    cy: 'GB',
+    da: 'DK',
+    de: 'DE',
+    el: 'GR',
+    en: 'GB',
+    es: 'ES',
+    et: 'EE',
+    eu: 'ES',
+    fa: 'IR',
+    fi: 'FI',
+    fr: 'FR',
+    ga: 'IE',
+    gd: 'GB',
+    gl: 'ES',
+    gu: 'IN',
+    ha: 'NG',
+    he: 'IL',
+    hi: 'IN',
+    hr: 'HR',
+    hu: 'HU',
+    hy: 'AM',
+    id: 'ID',
+    ig: 'NG',
+    is: 'IS',
+    it: 'IT',
+    ja: 'JP',
+    jv: 'ID',
+    ka: 'GE',
+    kk: 'KZ',
+    km: 'KH',
+    kn: 'IN',
+    ko: 'KR',
+    ky: 'KG',
+    lo: 'LA',
+    lt: 'LT',
+    lv: 'LV',
+    mk: 'MK',
+    ml: 'IN',
+    mn: 'MN',
+    mr: 'IN',
+    ms: 'MY',
+    mt: 'MT',
+    my: 'MM',
+    nb: 'NO',
+    ne: 'NP',
+    nl: 'NL',
+    nn: 'NO',
+    no: 'NO',
+    pa: 'IN',
+    pl: 'PL',
+    ps: 'AF',
+    pt: 'PT',
+    ro: 'RO',
+    ru: 'RU',
+    si: 'LK',
+    sk: 'SK',
+    sl: 'SI',
+    so: 'SO',
+    sq: 'AL',
+    sr: 'RS',
+    su: 'ID',
+    sv: 'SE',
+    sw: 'TZ',
+    ta: 'IN',
+    te: 'IN',
+    tg: 'TJ',
+    th: 'TH',
+    tk: 'TM',
+    tl: 'PH',
+    tr: 'TR',
+    uk: 'UA',
+    ur: 'PK',
+    uz: 'UZ',
+    vi: 'VN',
+    yo: 'NG',
+    zh: 'CN',
+    zu: 'ZA',
+}
+
+/** language[-Script][-REGION], lowercased: ids arrive slugged from the loader. */
+const LOCALE_RE = /^([a-z]{2})(?:-([a-z]{4}))?(?:-([a-z]{2}))?$/
+
+export interface Locale {
+    /** Lowercased directory name, and the URL segment. */
+    code: string
+    /** BCP-47, for `lang` and `hreflang`. */
+    tag: string
+    /** Native name, for the switcher menu. */
+    name: string
+    /** Emoji, or null for a language with no listed region. */
+    flag: string | null
+}
+
+export function isLocale(segment: string): boolean {
+    const match = LOCALE_RE.exec(segment.toLowerCase())
+    return match !== null && LANGUAGES.has(match[1])
+}
+
+/** "pt-br" becomes "pt-BR", "zh-hans" becomes "zh-Hans". */
+export function localeTag(code: string): string {
+    const match = LOCALE_RE.exec(code.toLowerCase())
+    if (!match) return code
+    const [, language, script, region] = match
+    return [language, script && ucfirst(script), region && region.toUpperCase()].filter(Boolean).join('-')
+}
+
+function localeName(tag: string): string {
+    try {
+        const names = new Intl.DisplayNames([tag], { type: 'language' })
+        return ucfirst(names.of(tag) ?? tag)
+    } catch {
+        return tag
+    }
+}
+
+/** Regional indicators, A at U+1F1E6. */
+function localeFlag(code: string): string | null {
+    const match = LOCALE_RE.exec(code.toLowerCase())
+    if (!match) return null
+    // A group that did not participate is undefined, whatever the type says.
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    const region = match[3]?.toUpperCase() ?? LANGUAGE_REGION[match[1]]
+    if (!region) return null
+    return String.fromCodePoint(...Array.from(region, (letter) => 0x1f1e6 + letter.charCodeAt(0) - 65))
+}
+
+/** Open Graph wants language_TERRITORY, not a BCP-47 tag. The territory comes
+ *  from the code when it names one, and from LANGUAGE_REGION otherwise. */
+export function openGraphLocale(code: string): string {
+    const match = LOCALE_RE.exec(code.toLowerCase())
+    if (!match) return code
+
+    const language = match[1]
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    const region = match[3]?.toUpperCase() ?? LANGUAGE_REGION[language]
+    return region ? `${language}_${region}` : language
+}
+
+export function describeLocale(code: string): Locale {
+    const tag = localeTag(code)
+    return { code, tag, name: localeName(tag), flag: localeFlag(code) }
+}
+
+/** Empty for the locale that owns the unprefixed urls. */
+export function localeSegment(locale?: string, defaultLocale?: string): string {
+    return !locale || locale === defaultLocale ? '' : locale
+}
+
+/** The segment a generated slug carries, with its separator. */
+export function localePrefix(locale?: string, defaultLocale?: string): string {
+    const segment = localeSegment(locale, defaultLocale)
+    return segment ? `${segment}/` : ''
+}
+
+/** What to iterate when building: every locale, or one unlocalised pass. */
+export function routedLocales(locales: Locale[]): (string | undefined)[] {
+    return locales.length > 0 ? locales.map((l) => l.code) : [undefined]
+}
+
+/** The locale codes whose urls carry a prefix. */
+export function prefixedLocales(locales: Locale[], defaultLocale: string): string[] {
+    return locales.map((locale) => locale.code).filter((code) => localeSegment(code, defaultLocale) !== '')
+}

package/src/navigation.ts

@@ -0,0 +1,97 @@
+import type { DocsNavItem } from './@types/docs.ts'
+import { docsPageHref, type DocsUrlOptions } from './urls.ts'
+import { docLabel, getCanonicalDocSlug, parseDocCollectionId, routedId, type DocsPageLike } from './utils/docs.ts'
+
+export type NavSection =
+    | { type: 'page'; order: number; item: DocsNavItem }
+    | { type: 'chapter'; order: number; chapter: string; items: DocsNavItem[] }
+
+export interface DocsNavigation {
+    sections: NavSection[]
+    previousPage: DocsNavItem | null
+    nextPage: DocsNavItem | null
+}
+
+function groupByChapter(items: DocsNavItem[]): NavSection[] {
+    const chapters = new Map<string, Extract<NavSection, { type: 'chapter' }>>()
+    const sections: NavSection[] = []
+
+    for (const item of items) {
+        if (!item.chapter) {
+            sections.push({ type: 'page', order: item.primaryOrder, item })
+            continue
+        }
+
+        let chapter = chapters.get(item.chapter)
+        if (!chapter) {
+            chapter = {
+                type: 'chapter',
+                order: item.primaryOrder,
+                chapter: item.chapter,
+                items: [],
+            }
+            chapters.set(item.chapter, chapter)
+            sections.push(chapter)
+        }
+        chapter.items.push(item)
+    }
+
+    return sections.toSorted((a, b) => a.order - b.order)
+}
+
+/** Build every navigation view from one ordered collection traversal. */
+interface Model {
+    items: DocsNavItem[]
+    positions: Map<string, number>
+}
+
+// Only isActive and the neighbours vary between the pages of one locale. The
+// hrefs do not, as long as the url options are the same ones.
+const models = new WeakMap<object, Map<string, Model>>()
+
+function modelFor(sortedPages: DocsPageLike[], urls: DocsUrlOptions): Model {
+    const key = `${urls.docsBase}\u0000${urls.deploymentBase ?? ''}\u0000${urls.locale ?? ''}\u0000${urls.defaultLocale ?? ''}`
+    let byUrls = models.get(sortedPages)
+    if (!byUrls) {
+        byUrls = new Map()
+        models.set(sortedPages, byUrls)
+    }
+    const cached = byUrls.get(key)
+    if (cached) return cached
+
+    const model: Model = {
+        items: sortedPages.map((page, index): DocsNavItem => {
+            const parsed = parseDocCollectionId(routedId(page))
+            return {
+                title: docLabel(page),
+                chapter: parsed.chapter,
+                primaryOrder: parsed.orderChapter ?? page.data?.order ?? parsed.order,
+                href: docsPageHref(getCanonicalDocSlug(page, index), urls),
+                isActive: false,
+            }
+        }),
+        positions: new Map(sortedPages.map((page, index) => [page.id, index])),
+    }
+
+    byUrls.set(key, model)
+    return model
+}
+
+export function buildDocsNavigation(
+    sortedPages: DocsPageLike[],
+    currentId: string,
+    urls: DocsUrlOptions,
+): DocsNavigation {
+    const { items, positions } = modelFor(sortedPages, urls)
+    const currentIndex = positions.get(currentId) ?? -1
+    const marked = items.map((item, index) => ({
+        ...item,
+        isActive: index === currentIndex,
+    }))
+
+    return {
+        sections: groupByChapter(marked),
+        previousPage: currentIndex > 0 ? marked[currentIndex - 1] : null,
+        nextPage: currentIndex >= 0 && currentIndex < marked.length - 1 ? marked[currentIndex + 1] : null,
+    }
+}

package/src/routes/404.astro

@@ -0,0 +1,16 @@
+---
+import Layout from '../layouts/Page.astro'
+import { withDeploymentBase } from '../urls.ts'
+
+const homeHref = withDeploymentBase('/', import.meta.env.BASE_URL)
+---
+
+<Layout title="404" description="The page you're looking for doesn't exist.">
+    <div class="jaad-not-found">
+        <h1 class="jaad-not-found-title">404</h1>
+        <p class="jaad-not-found-text">
+            <i>Oops!</i> The page you're looking for doesn't exist.
+        </p>
+        <a href={homeHref}>Go back to the homepage</a>
+    </div>
+</Layout>

package/src/routes/docs-index.astro

@@ -0,0 +1,19 @@
+---
+import { render } from 'astro:content'
+import { getSortedDocsPages } from '../collection.ts'
+import DocsPage from '../components/docs/DocsPage.astro'
+import { withDeploymentBase } from '../urls.ts'
+
+const sortedPages = await getSortedDocsPages()
+
+const firstPage = sortedPages[0]
+if (!firstPage) {
+    return Astro.redirect(withDeploymentBase('/404', import.meta.env.BASE_URL))
+}
+
+const { Content } = await render(firstPage)
+---
+
+<DocsPage entry={firstPage} {sortedPages}>
+    <Content />
+</DocsPage>

package/src/routes/docs-slug.astro

@@ -0,0 +1,58 @@
+---
+import { render } from 'astro:content'
+import { getSortedDocsPages } from '../collection.ts'
+import DocsPage from '../components/docs/DocsPage.astro'
+import { buildLocales, docsUrls, localePrefix } from '../docs-config.ts'
+import { docsPageHref, withDeploymentBase } from '../urls.ts'
+import { getCanonicalDocSlug, getCleanSlug, docTitle, routedId } from '../utils/docs.ts'
+
+interface DocsPath {
+    params: { slug: string }
+    props: { id: string; locale?: string; isOpening: boolean }
+}
+
+export async function getStaticPaths() {
+    const paths: DocsPath[] = []
+
+    for (const locale of buildLocales()) {
+        const sortedPages = await getSortedDocsPages(locale)
+        const prefix = localePrefix(locale)
+
+        sortedPages.forEach((page, index) => {
+            const isOpening = getCanonicalDocSlug(page, index) === ''
+            paths.push({
+                params: { slug: `${prefix}${getCleanSlug(routedId(page))}` },
+                props: { id: page.id, locale, isOpening },
+            })
+
+            // A prefixed locale has no index route of its own: /it is this page.
+            if (isOpening && prefix) {
+                paths.push({
+                    params: { slug: locale! },
+                    props: { id: page.id, locale, isOpening: false },
+                })
+            }
+        })
+    }
+
+    return paths
+}
+
+const { id, locale, isOpening } = Astro.props
+
+if (isOpening) {
+    return Astro.redirect(docsPageHref('', docsUrls(locale)), 301)
+}
+
+const sortedPages = await getSortedDocsPages(locale)
+const docPage = sortedPages.find((page) => page.id === id)
+if (!docPage) {
+    return Astro.redirect(withDeploymentBase('/404', import.meta.env.BASE_URL))
+}
+
+const { Content } = await render(docPage)
+---
+
+<DocsPage entry={docPage} {sortedPages} headTitle={docTitle(docPage)}>
+    <Content />
+</DocsPage>

package/src/routes/docs-slug.md.ts

@@ -0,0 +1,37 @@
+import type { APIRoute, GetStaticPaths } from 'astro'
+import { getSortedDocsPages } from '../collection.ts'
+import { buildLocales, localePrefix } from '../docs-config.ts'
+import { getCleanSlug, routedId } from '../utils/docs.ts'
+
+/** Raw markdown at the page's own url plus `.md`, for readers and for LLMs. */
+export const getStaticPaths: GetStaticPaths = async () => {
+    const paths: {
+        params: { slug: string }
+        props: { id: string; locale?: string }
+    }[] = []
+
+    for (const locale of buildLocales()) {
+        const sortedPages = await getSortedDocsPages(locale)
+        const prefix = localePrefix(locale)
+
+        for (const page of sortedPages) {
+            paths.push({
+                params: { slug: `${prefix}${getCleanSlug(routedId(page))}` },
+                props: { id: page.id, locale },
+            })
+        }
+    }
+
+    return paths
+}
+
+export const GET: APIRoute = async ({ props }) => {
+    const { id, locale } = props as { id: string; locale?: string }
+    const pages = await getSortedDocsPages(locale)
+    const entry = pages.find((page) => page.id === id)
+    if (!entry) return new Response('Not found', { status: 404 })
+
+    return new Response(entry.body ?? '', {
+        headers: { 'Content-Type': 'text/markdown; charset=utf-8' },
+    })
+}

package/src/routes/llms-locale.txt.ts

@@ -0,0 +1,8 @@
+import type { APIRoute, GetStaticPaths } from 'astro'
+import { getServedLocales } from '../collection.ts'
+import { llmsResponse } from '../utils/endpoints.ts'
+
+export const getStaticPaths: GetStaticPaths = async () =>
+    (await getServedLocales()).map((locale) => ({ params: { locale } }))
+
+export const GET: APIRoute = ({ site, params }) => llmsResponse(site, params.locale)