livemark 0.25.0 → 0.27.0

package/build/helpers/dependency-dir.unit.js

@@ -0,0 +1,25 @@
+import { realpathSync } from "node:fs";
+import { mkdir } from "node:fs/promises";
+import { join } from "node:path";
+import { temporaryDirectoryTask } from "tempy";
+import { describe, expect, it } from "vite-plus/test";
+import { resolveDependencyDir } from "./dependency-dir.js";
+describe("resolveDependencyDir", () => {
+    it("uses the store dir beside an isolated install", () => temporaryDirectoryTask(async (root) => {
+        const store = join(root, ".pnpm/livemark@1.0.0/node_modules");
+        await mkdir(join(store, "livemark/source"), { recursive: true });
+        await mkdir(join(store, "livemark/node_modules/.bin"), { recursive: true });
+        expect(resolveDependencyDir(join(store, "livemark/source"))).toBe(realpathSync(store));
+    }));
+    it("uses the package's own node_modules when it has one", () => temporaryDirectoryTask(async (root) => {
+        const packageDir = join(root, "node_modules/livemark");
+        await mkdir(join(packageDir, "source"), { recursive: true });
+        await mkdir(join(packageDir, "node_modules/zod"), { recursive: true });
+        expect(resolveDependencyDir(join(packageDir, "source"))).toBe(join(realpathSync(packageDir), "node_modules"));
+    }));
+    it("uses the checkout's node_modules outside an install", () => temporaryDirectoryTask(async (root) => {
+        await mkdir(join(root, "livemark/source"), { recursive: true });
+        expect(resolveDependencyDir(join(root, "livemark/source"))).toBe(join(realpathSync(root), "livemark/node_modules"));
+    }));
+});
+//# sourceMappingURL=data:application/json;base64,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

package/build/helpers/dynamic-icon-resolver.d.ts

@@ -2,4 +2,4 @@
 export default function DynamicIconResolver(props: {
     name: string;
     className?: string;
-}): import("react/jsx-runtime").JSX.Element | null;
+}): import("react").JSX.Element | null;

package/build/helpers/dynamic-icon.d.ts

@@ -2,4 +2,4 @@
 export declare function DynamicIcon(props: {
     name: string;
     className?: string;
-}): import("react/jsx-runtime").JSX.Element;
+}): import("react").JSX.Element;

package/build/helpers/head.d.ts

@@ -0,0 +1,58 @@
+import type * as React from "react";
+import type { WebsiteConfig } from "../models/config.ts";
+/** Site-wide `<head>` tags the root route renders on every page. */
+export interface RootHead {
+    meta: Array<React.JSX.IntrinsicElements["meta"]>;
+    links: Array<React.JSX.IntrinsicElements["link"]>;
+    scripts: Array<React.JSX.IntrinsicElements["script"]>;
+}
+export declare function buildRootHead(props: {
+    config: WebsiteConfig;
+    defaultFavicon: string;
+    stylesheets: string[];
+}): {
+    meta: Record<string, string>[];
+    links: (Record<string, string> | {
+        rel: string;
+        href: string;
+        type: string | undefined;
+    } | {
+        rel: string;
+        href: string;
+    })[];
+    scripts: Record<string, string>[];
+};
+export declare function buildPageHead(props: {
+    config: WebsiteConfig;
+    path: string;
+    title?: string;
+    description?: string;
+    image?: string;
+    isArticle?: boolean;
+}): {
+    meta: ({
+        title: string;
+        property?: undefined;
+        name?: undefined;
+        content?: undefined;
+    } | {
+        title?: undefined;
+        property: string;
+        content: string;
+        name?: undefined;
+    } | {
+        title?: undefined;
+        property?: undefined;
+        name: string;
+        content: string;
+    })[];
+    links: ({
+        rel: string;
+        href: string;
+        type?: undefined;
+    } | {
+        rel: string;
+        type: string;
+        href: string;
+    })[];
+};

package/build/helpers/head.js

@@ -0,0 +1,80 @@
+import { faviconType } from "./favicon.js";
+import { prefixUrl } from "./prefix-url.js";
+import { buildThemeScript } from "./theme.js";
+export function buildRootHead(props) {
+    const config = props.config;
+    const favicon = prefixUrl(config.favicon ?? config.logo ?? props.defaultFavicon, config.base);
+    const feedLinks = config.site
+        ? (config.sections ?? [])
+            .filter(s => s.type === "blog")
+            .map(s => ({
+            rel: "alternate",
+            type: "application/rss+xml",
+            title: `${s.siteTitle ?? s.title} RSS Feed`,
+            href: prefixUrl(`${s.prefix}rss.xml`, config.base),
+        }))
+        : [];
+    return {
+        meta: [
+            { charSet: "utf-8" },
+            { title: config.title },
+            { name: "description", content: config.description },
+            { property: "og:title", content: config.title },
+            { property: "og:description", content: config.description },
+            { property: "og:site_name", content: config.title },
+            { property: "og:type", content: "website" },
+            { name: "viewport", content: "width=device-width, initial-scale=1" },
+            ...(config.head?.meta ?? []),
+        ],
+        links: [
+            { rel: "icon", href: favicon, type: faviconType(favicon) },
+            { rel: "shortcut icon", href: favicon, type: faviconType(favicon) },
+            ...props.stylesheets.map(href => ({ rel: "stylesheet", href })),
+            ...feedLinks,
+            ...(config.head?.links ?? []),
+        ],
+        scripts: [{ children: buildThemeScript() }, ...(config.head?.scripts ?? [])],
+    };
+}
+export function buildPageHead(props) {
+    const site = props.config.site?.replace(/\/+$/, "");
+    const url = site ? buildAbsoluteUrl(site, props.config.base, props.path) : undefined;
+    const image = site && props.image
+        ? buildAbsoluteUrl(site, props.config.base, props.image)
+        : undefined;
+    return {
+        meta: [
+            ...(props.title
+                ? [{ title: props.title }, { property: "og:title", content: props.title }]
+                : []),
+            ...(props.description
+                ? [
+                    { name: "description", content: props.description },
+                    { property: "og:description", content: props.description },
+                ]
+                : []),
+            ...(props.isArticle ? [{ property: "og:type", content: "article" }] : []),
+            ...(url ? [{ property: "og:url", content: url }] : []),
+            ...(image ? [{ property: "og:image", content: image }] : []),
+        ],
+        links: [
+            ...(url ? [{ rel: "canonical", href: url }] : []),
+            ...(props.isArticle
+                ? [
+                    {
+                        rel: "alternate",
+                        type: "text/markdown",
+                        href: prefixUrl(`${props.path}index.md`, props.config.base),
+                    },
+                ]
+                : []),
+        ],
+    };
+}
+function buildAbsoluteUrl(site, base, url) {
+    const prefixed = prefixUrl(url, base);
+    if (!prefixed.startsWith("/") || prefixed.startsWith("//"))
+        return prefixed;
+    return `${site}${prefixed}`;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"head.js","sourceRoot":"","sources":["../../source/helpers/head.ts"],"names":[],"mappings":"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","sourcesContent":["import type * as React from \"react\"\nimport type { WebsiteConfig } from \"../models/config.ts\"\nimport { faviconType } from \"./favicon.ts\"\nimport { prefixUrl } from \"./prefix-url.ts\"\nimport { buildThemeScript } from \"./theme.ts\"\n\n/** Site-wide `<head>` tags the root route renders on every page. */\nexport interface RootHead {\n  meta: Array<React.JSX.IntrinsicElements[\"meta\"]>\n  links: Array<React.JSX.IntrinsicElements[\"link\"]>\n  scripts: Array<React.JSX.IntrinsicElements[\"script\"]>\n}\n\nexport function buildRootHead(props: {\n  config: WebsiteConfig\n  defaultFavicon: string\n  stylesheets: string[]\n}) {\n  const config = props.config\n  const favicon = prefixUrl(\n    config.favicon ?? config.logo ?? props.defaultFavicon,\n    config.base,\n  )\n  const feedLinks = config.site\n    ? (config.sections ?? [])\n        .filter(s => s.type === \"blog\")\n        .map(s => ({\n          rel: \"alternate\",\n          type: \"application/rss+xml\",\n          title: `${s.siteTitle ?? s.title} RSS Feed`,\n          href: prefixUrl(`${s.prefix}rss.xml`, config.base),\n        }))\n    : []\n  return {\n    meta: [\n      { charSet: \"utf-8\" },\n      { title: config.title },\n      { name: \"description\", content: config.description },\n      { property: \"og:title\", content: config.title },\n      { property: \"og:description\", content: config.description },\n      { property: \"og:site_name\", content: config.title },\n      { property: \"og:type\", content: \"website\" },\n      { name: \"viewport\", content: \"width=device-width, initial-scale=1\" },\n      ...(config.head?.meta ?? []),\n    ],\n    links: [\n      { rel: \"icon\", href: favicon, type: faviconType(favicon) },\n      { rel: \"shortcut icon\", href: favicon, type: faviconType(favicon) },\n      ...props.stylesheets.map(href => ({ rel: \"stylesheet\", href })),\n      ...feedLinks,\n      ...(config.head?.links ?? []),\n    ],\n    scripts: [{ children: buildThemeScript() }, ...(config.head?.scripts ?? [])],\n  }\n}\n\nexport function buildPageHead(props: {\n  config: WebsiteConfig\n  path: string\n  title?: string\n  description?: string\n  image?: string\n  isArticle?: boolean\n}) {\n  const site = props.config.site?.replace(/\\/+$/, \"\")\n  const url = site ? buildAbsoluteUrl(site, props.config.base, props.path) : undefined\n  const image =\n    site && props.image\n      ? buildAbsoluteUrl(site, props.config.base, props.image)\n      : undefined\n  return {\n    meta: [\n      ...(props.title\n        ? [{ title: props.title }, { property: \"og:title\", content: props.title }]\n        : []),\n      ...(props.description\n        ? [\n            { name: \"description\", content: props.description },\n            { property: \"og:description\", content: props.description },\n          ]\n        : []),\n      ...(props.isArticle ? [{ property: \"og:type\", content: \"article\" }] : []),\n      ...(url ? [{ property: \"og:url\", content: url }] : []),\n      ...(image ? [{ property: \"og:image\", content: image }] : []),\n    ],\n    links: [\n      ...(url ? [{ rel: \"canonical\", href: url }] : []),\n      ...(props.isArticle\n        ? [\n            {\n              rel: \"alternate\",\n              type: \"text/markdown\",\n              href: prefixUrl(`${props.path}index.md`, props.config.base),\n            },\n          ]\n        : []),\n    ],\n  }\n}\n\nfunction buildAbsoluteUrl(site: string, base: string | undefined, url: string) {\n  const prefixed = prefixUrl(url, base)\n  if (!prefixed.startsWith(\"/\") || prefixed.startsWith(\"//\")) return prefixed\n  return `${site}${prefixed}`\n}\n"]}

package/build/helpers/head.unit.d.ts

@@ -0,0 +1 @@
+export {};

package/build/helpers/head.unit.js

@@ -0,0 +1,110 @@
+import { describe, expect, it } from "vite-plus/test";
+import { buildPageHead, buildRootHead } from "./head.js";
+const config = { title: "Docs", description: "Blurb" };
+describe("buildRootHead", () => {
+    it("builds the default site tags", () => {
+        const head = buildRootHead({
+            config,
+            defaultFavicon: "/logo.svg",
+            stylesheets: ["/a.css"],
+        });
+        expect(head.meta).toContainEqual({ property: "og:title", content: "Docs" });
+        expect(head.links).toContainEqual({
+            rel: "icon",
+            href: "/logo.svg",
+            type: "image/svg+xml",
+        });
+        expect(head.links).toContainEqual({ rel: "stylesheet", href: "/a.css" });
+        expect(head.scripts).toHaveLength(1);
+    });
+    it("appends config head tags after the defaults", () => {
+        const head = buildRootHead({
+            config: {
+                ...config,
+                head: {
+                    meta: [{ property: "og:type", content: "book" }],
+                    links: [{ rel: "me", href: "https://x.com/me" }],
+                    scripts: [{ src: "https://cdn.example.com/a.js" }],
+                },
+            },
+            defaultFavicon: "/logo.svg",
+            stylesheets: [],
+        });
+        expect(head.meta.at(-1)).toEqual({ property: "og:type", content: "book" });
+        expect(head.links.at(-1)).toEqual({ rel: "me", href: "https://x.com/me" });
+        expect(head.scripts.at(-1)).toEqual({ src: "https://cdn.example.com/a.js" });
+    });
+    it("links blog feeds only when site is set", () => {
+        const sections = [
+            { type: "blog", title: "Blog", prefix: "/blog/", position: "header" },
+        ];
+        const withoutSite = buildRootHead({
+            config: { ...config, sections },
+            defaultFavicon: "/logo.svg",
+            stylesheets: [],
+        });
+        const withSite = buildRootHead({
+            config: { ...config, sections, site: "https://example.com", base: "/repo" },
+            defaultFavicon: "/logo.svg",
+            stylesheets: [],
+        });
+        expect(withoutSite.links.some(l => l.rel === "alternate")).toBe(false);
+        expect(withSite.links).toContainEqual({
+            rel: "alternate",
+            type: "application/rss+xml",
+            title: "Blog RSS Feed",
+            href: "/repo/blog/rss.xml",
+        });
+    });
+});
+describe("buildPageHead", () => {
+    it("emits title, description and article type", () => {
+        const head = buildPageHead({
+            config,
+            path: "/guide/",
+            title: "Guide",
+            description: "How to",
+            isArticle: true,
+        });
+        expect(head.meta).toEqual([
+            { title: "Guide" },
+            { property: "og:title", content: "Guide" },
+            { name: "description", content: "How to" },
+            { property: "og:description", content: "How to" },
+            { property: "og:type", content: "article" },
+        ]);
+        expect(head.links).toEqual([
+            { rel: "alternate", type: "text/markdown", href: "/guide/index.md" },
+        ]);
+    });
+    it("adds absolute url, canonical and image when site is set", () => {
+        const head = buildPageHead({
+            config: { ...config, site: "https://example.com/", base: "/repo" },
+            path: "/guide/",
+            image: "/repo/assets/cover.png",
+        });
+        expect(head.meta).toEqual([
+            { property: "og:url", content: "https://example.com/repo/guide/" },
+            { property: "og:image", content: "https://example.com/repo/assets/cover.png" },
+        ]);
+        expect(head.links).toEqual([
+            { rel: "canonical", href: "https://example.com/repo/guide/" },
+        ]);
+    });
+    it("keeps an already absolute image", () => {
+        const head = buildPageHead({
+            config: { ...config, site: "https://example.com" },
+            path: "/",
+            image: "https://cdn.example.com/cover.png",
+        });
+        expect(head.meta).toContainEqual({
+            property: "og:image",
+            content: "https://cdn.example.com/cover.png",
+        });
+    });
+    it("skips og:image without site", () => {
+        const head = buildPageHead({ config, path: "/", image: "/cover.png" });
+        expect(head.meta).toEqual([]);
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"head.unit.js","sourceRoot":"","sources":["../../source/helpers/head.unit.ts"],"names":[],"mappings":"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","sourcesContent":["import { describe, expect, it } from \"vite-plus/test\"\nimport type { WebsiteConfig } from \"../models/config.ts\"\nimport { buildPageHead, buildRootHead } from \"./head.ts\"\n\nconst config: WebsiteConfig = { title: \"Docs\", description: \"Blurb\" }\n\ndescribe(\"buildRootHead\", () => {\n  it(\"builds the default site tags\", () => {\n    const head = buildRootHead({\n      config,\n      defaultFavicon: \"/logo.svg\",\n      stylesheets: [\"/a.css\"],\n    })\n    expect(head.meta).toContainEqual({ property: \"og:title\", content: \"Docs\" })\n    expect(head.links).toContainEqual({\n      rel: \"icon\",\n      href: \"/logo.svg\",\n      type: \"image/svg+xml\",\n    })\n    expect(head.links).toContainEqual({ rel: \"stylesheet\", href: \"/a.css\" })\n    expect(head.scripts).toHaveLength(1)\n  })\n\n  it(\"appends config head tags after the defaults\", () => {\n    const head = buildRootHead({\n      config: {\n        ...config,\n        head: {\n          meta: [{ property: \"og:type\", content: \"book\" }],\n          links: [{ rel: \"me\", href: \"https://x.com/me\" }],\n          scripts: [{ src: \"https://cdn.example.com/a.js\" }],\n        },\n      },\n      defaultFavicon: \"/logo.svg\",\n      stylesheets: [],\n    })\n    expect(head.meta.at(-1)).toEqual({ property: \"og:type\", content: \"book\" })\n    expect(head.links.at(-1)).toEqual({ rel: \"me\", href: \"https://x.com/me\" })\n    expect(head.scripts.at(-1)).toEqual({ src: \"https://cdn.example.com/a.js\" })\n  })\n\n  it(\"links blog feeds only when site is set\", () => {\n    const sections: WebsiteConfig[\"sections\"] = [\n      { type: \"blog\", title: \"Blog\", prefix: \"/blog/\", position: \"header\" },\n    ]\n    const withoutSite = buildRootHead({\n      config: { ...config, sections },\n      defaultFavicon: \"/logo.svg\",\n      stylesheets: [],\n    })\n    const withSite = buildRootHead({\n      config: { ...config, sections, site: \"https://example.com\", base: \"/repo\" },\n      defaultFavicon: \"/logo.svg\",\n      stylesheets: [],\n    })\n    expect(withoutSite.links.some(l => l.rel === \"alternate\")).toBe(false)\n    expect(withSite.links).toContainEqual({\n      rel: \"alternate\",\n      type: \"application/rss+xml\",\n      title: \"Blog RSS Feed\",\n      href: \"/repo/blog/rss.xml\",\n    })\n  })\n})\n\ndescribe(\"buildPageHead\", () => {\n  it(\"emits title, description and article type\", () => {\n    const head = buildPageHead({\n      config,\n      path: \"/guide/\",\n      title: \"Guide\",\n      description: \"How to\",\n      isArticle: true,\n    })\n    expect(head.meta).toEqual([\n      { title: \"Guide\" },\n      { property: \"og:title\", content: \"Guide\" },\n      { name: \"description\", content: \"How to\" },\n      { property: \"og:description\", content: \"How to\" },\n      { property: \"og:type\", content: \"article\" },\n    ])\n    expect(head.links).toEqual([\n      { rel: \"alternate\", type: \"text/markdown\", href: \"/guide/index.md\" },\n    ])\n  })\n\n  it(\"adds absolute url, canonical and image when site is set\", () => {\n    const head = buildPageHead({\n      config: { ...config, site: \"https://example.com/\", base: \"/repo\" },\n      path: \"/guide/\",\n      image: \"/repo/assets/cover.png\",\n    })\n    expect(head.meta).toEqual([\n      { property: \"og:url\", content: \"https://example.com/repo/guide/\" },\n      { property: \"og:image\", content: \"https://example.com/repo/assets/cover.png\" },\n    ])\n    expect(head.links).toEqual([\n      { rel: \"canonical\", href: \"https://example.com/repo/guide/\" },\n    ])\n  })\n\n  it(\"keeps an already absolute image\", () => {\n    const head = buildPageHead({\n      config: { ...config, site: \"https://example.com\" },\n      path: \"/\",\n      image: \"https://cdn.example.com/cover.png\",\n    })\n    expect(head.meta).toContainEqual({\n      property: \"og:image\",\n      content: \"https://cdn.example.com/cover.png\",\n    })\n  })\n\n  it(\"skips og:image without site\", () => {\n    const head = buildPageHead({ config, path: \"/\", image: \"/cover.png\" })\n    expect(head.meta).toEqual([])\n  })\n})\n"]}

package/build/helpers/llms.d.ts

@@ -0,0 +1,33 @@
+import type { Config } from "../models/config.ts";
+import type { RoutedSection } from "../models/section.ts";
+/** The slice of a built article that agent-facing files are rendered from. */
+export interface LlmsArticle {
+    path: string;
+    title: string;
+    description?: string;
+    order?: number;
+    date?: string;
+}
+/** Render `llms.txt`: the site title and description, then one Markdown link
+ *  per article twin, grouped under each routed section in sidebar order. */
+export declare function renderLlmsText(props: {
+    config: Pick<Config, "title" | "description" | "site" | "base" | "sections">;
+    articles: LlmsArticle[];
+}): string;
+/** Render the Markdown twin of a section's index page (a blog or changelog
+ *  listing), which has no article of its own: links to the section's articles. */
+export declare function renderSectionIndex(props: {
+    config: Pick<Config, "site" | "base" | "sections">;
+    section: RoutedSection;
+    articles: LlmsArticle[];
+}): string;
+/** Render the Markdown twin of an article: its title and description as the
+ *  rendered page shows them, then the body without its own leading h1. */
+export declare function renderMarkdownTwin(props: {
+    article: LlmsArticle;
+    content: string;
+}): string;
+/** Path of an article's Markdown twin inside the build output (no base). */
+export declare function buildTwinFileName(path: string): string;
+/** Drop a leading h1 so a title set by frontmatter or a patch is not shown twice */
+export declare function stripLeadingH1(content: string): string;

package/build/helpers/llms.js

@@ -0,0 +1,72 @@
+import { buildArticleTree, compareArticleDate, compareArticleOrder, flattenArticleTree, } from "./article.js";
+import { partitionBySection } from "./section.js";
+/** Render `llms.txt`: the site title and description, then one Markdown link
+ *  per article twin, grouped under each routed section in sidebar order. */
+export function renderLlmsText(props) {
+    const lines = [`# ${props.config.title}`, "", `> ${props.config.description}`];
+    for (const group of groupArticles(props)) {
+        lines.push("", `## ${group.title}`, "", ...renderLinks(props.config, group.articles));
+    }
+    return `${lines.join("\n")}\n`;
+}
+/** Render the Markdown twin of a section's index page (a blog or changelog
+ *  listing), which has no article of its own: links to the section's articles. */
+export function renderSectionIndex(props) {
+    const group = groupArticles(props).find(g => g.prefix === props.section.prefix);
+    const lines = [
+        `# ${props.section.title}`,
+        "",
+        ...renderLinks(props.config, group?.articles ?? []),
+    ];
+    return `${lines.join("\n")}\n`;
+}
+/** Render the Markdown twin of an article: its title and description as the
+ *  rendered page shows them, then the body without its own leading h1. */
+export function renderMarkdownTwin(props) {
+    const article = props.article;
+    const parts = [`# ${article.title}`];
+    if (article.description)
+        parts.push(`> ${article.description}`);
+    parts.push(stripLeadingH1(props.content).trim());
+    return `${parts.join("\n\n")}\n`;
+}
+/** Path of an article's Markdown twin inside the build output (no base). */
+export function buildTwinFileName(path) {
+    return `${path.replace(/^\//, "")}index.md`;
+}
+/** Drop a leading h1 so a title set by frontmatter or a patch is not shown twice */
+export function stripLeadingH1(content) {
+    return content.replace(/^[ \t]*#\s+[^\n]*\n+/, "");
+}
+function buildTwinUrl(config, path) {
+    const host = config.site?.replace(/\/+$/, "") ?? "";
+    return `${host}${config.base ?? ""}${path}index.md`;
+}
+function groupArticles(props) {
+    const sections = props.config.sections?.filter((s) => s.type !== "custom") ?? [];
+    const buckets = partitionBySection([...props.articles].sort(compareArticleOrder), sections);
+    const groups = [
+        ...sections.map(s => ({
+            prefix: s.prefix,
+            title: s.title,
+            dated: s.type !== "article",
+        })),
+        { prefix: "__default__", title: sections.length ? "Other" : "Pages", dated: false },
+    ];
+    return groups.flatMap(group => {
+        const bucket = buckets.get(group.prefix);
+        if (!bucket?.length)
+            return [];
+        const articles = group.dated
+            ? [...bucket].sort(compareArticleDate)
+            : flattenArticleTree(buildArticleTree(bucket)).flatMap(path => bucket.find(a => a.path === path) ?? []);
+        return [{ prefix: group.prefix, title: group.title, articles }];
+    });
+}
+function renderLinks(config, articles) {
+    return articles.map(article => {
+        const link = `[${article.title}](${buildTwinUrl(config, article.path)})`;
+        return article.description ? `- ${link}: ${article.description}` : `- ${link}`;
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"llms.js","sourceRoot":"","sources":["../../source/helpers/llms.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Config } from \"../models/config.ts\"\nimport type { RoutedSection } from \"../models/section.ts\"\nimport {\n  buildArticleTree,\n  compareArticleDate,\n  compareArticleOrder,\n  flattenArticleTree,\n} from \"./article.ts\"\nimport { partitionBySection } from \"./section.ts\"\n\n/** The slice of a built article that agent-facing files are rendered from. */\nexport interface LlmsArticle {\n  path: string\n  title: string\n  description?: string\n  order?: number\n  date?: string\n}\n\n/** Render `llms.txt`: the site title and description, then one Markdown link\n *  per article twin, grouped under each routed section in sidebar order. */\nexport function renderLlmsText(props: {\n  config: Pick<Config, \"title\" | \"description\" | \"site\" | \"base\" | \"sections\">\n  articles: LlmsArticle[]\n}) {\n  const lines = [`# ${props.config.title}`, \"\", `> ${props.config.description}`]\n  for (const group of groupArticles(props)) {\n    lines.push(\"\", `## ${group.title}`, \"\", ...renderLinks(props.config, group.articles))\n  }\n  return `${lines.join(\"\\n\")}\\n`\n}\n\n/** Render the Markdown twin of a section's index page (a blog or changelog\n *  listing), which has no article of its own: links to the section's articles. */\nexport function renderSectionIndex(props: {\n  config: Pick<Config, \"site\" | \"base\" | \"sections\">\n  section: RoutedSection\n  articles: LlmsArticle[]\n}) {\n  const group = groupArticles(props).find(g => g.prefix === props.section.prefix)\n  const lines = [\n    `# ${props.section.title}`,\n    \"\",\n    ...renderLinks(props.config, group?.articles ?? []),\n  ]\n  return `${lines.join(\"\\n\")}\\n`\n}\n\n/** Render the Markdown twin of an article: its title and description as the\n *  rendered page shows them, then the body without its own leading h1. */\nexport function renderMarkdownTwin(props: { article: LlmsArticle; content: string }) {\n  const article = props.article\n  const parts = [`# ${article.title}`]\n  if (article.description) parts.push(`> ${article.description}`)\n  parts.push(stripLeadingH1(props.content).trim())\n  return `${parts.join(\"\\n\\n\")}\\n`\n}\n\n/** Path of an article's Markdown twin inside the build output (no base). */\nexport function buildTwinFileName(path: string) {\n  return `${path.replace(/^\\//, \"\")}index.md`\n}\n\n/** Drop a leading h1 so a title set by frontmatter or a patch is not shown twice */\nexport function stripLeadingH1(content: string) {\n  return content.replace(/^[ \\t]*#\\s+[^\\n]*\\n+/, \"\")\n}\n\nfunction buildTwinUrl(config: Pick<Config, \"site\" | \"base\">, path: string) {\n  const host = config.site?.replace(/\\/+$/, \"\") ?? \"\"\n  return `${host}${config.base ?? \"\"}${path}index.md`\n}\n\nfunction groupArticles(props: {\n  config: Pick<Config, \"sections\">\n  articles: LlmsArticle[]\n}) {\n  const sections =\n    props.config.sections?.filter((s): s is RoutedSection => s.type !== \"custom\") ?? []\n  const buckets = partitionBySection(\n    [...props.articles].sort(compareArticleOrder),\n    sections,\n  )\n  const groups = [\n    ...sections.map(s => ({\n      prefix: s.prefix,\n      title: s.title,\n      dated: s.type !== \"article\",\n    })),\n    { prefix: \"__default__\", title: sections.length ? \"Other\" : \"Pages\", dated: false },\n  ]\n  return groups.flatMap(group => {\n    const bucket = buckets.get(group.prefix)\n    if (!bucket?.length) return []\n    const articles = group.dated\n      ? [...bucket].sort(compareArticleDate)\n      : flattenArticleTree(buildArticleTree(bucket)).flatMap(\n          path => bucket.find(a => a.path === path) ?? [],\n        )\n    return [{ prefix: group.prefix, title: group.title, articles }]\n  })\n}\n\nfunction renderLinks(config: Pick<Config, \"site\" | \"base\">, articles: LlmsArticle[]) {\n  return articles.map(article => {\n    const link = `[${article.title}](${buildTwinUrl(config, article.path)})`\n    return article.description ? `- ${link}: ${article.description}` : `- ${link}`\n  })\n}\n"]}

package/build/helpers/llms.unit.d.ts

@@ -0,0 +1 @@
+export {};

package/build/helpers/llms.unit.js

@@ -0,0 +1,98 @@
+import { describe, expect, it } from "vite-plus/test";
+import { buildTwinFileName, renderLlmsText, renderMarkdownTwin, renderSectionIndex, } from "./llms.js";
+const config = { title: "Docs", description: "Blurb" };
+describe("renderLlmsText", () => {
+    it("lists articles in sidebar order under a single heading without sections", () => {
+        const text = renderLlmsText({
+            config,
+            articles: [
+                { path: "/guide/", title: "Guide", order: 2 },
+                { path: "/intro/", title: "Intro", description: "Start here", order: 1 },
+                { path: "/guide/deep/", title: "Deep" },
+            ],
+        });
+        expect(text).toBe([
+            "# Docs",
+            "",
+            "> Blurb",
+            "",
+            "## Pages",
+            "",
+            "- [Intro](/intro/index.md): Start here",
+            "- [Guide](/guide/index.md)",
+            "- [Deep](/guide/deep/index.md)",
+            "",
+        ].join("\n"));
+    });
+    it("groups by routed section, newest first in a blog, with absolute urls", () => {
+        const text = renderLlmsText({
+            config: {
+                ...config,
+                site: "https://example.com/",
+                base: "/repo",
+                sections: [
+                    { title: "Docs", prefix: "/", type: "article", position: "header" },
+                    { title: "Blog", prefix: "/blog/", type: "blog", position: "header" },
+                    {
+                        title: "GitHub",
+                        url: "https://github.com",
+                        type: "custom",
+                        position: "header",
+                    },
+                ],
+            },
+            articles: [
+                { path: "/blog/old/", title: "Old", date: "2026-01-01" },
+                { path: "/intro/", title: "Intro" },
+                { path: "/blog/new/", title: "New", date: "2026-02-01" },
+            ],
+        });
+        expect(text).toContain([
+            "## Docs",
+            "",
+            "- [Intro](https://example.com/repo/intro/index.md)",
+            "",
+            "## Blog",
+            "",
+            "- [New](https://example.com/repo/blog/new/index.md)",
+            "- [Old](https://example.com/repo/blog/old/index.md)",
+        ].join("\n"));
+        expect(text).not.toContain("GitHub");
+    });
+});
+describe("renderSectionIndex", () => {
+    it("lists only the section's articles, newest first", () => {
+        const blog = {
+            title: "Blog",
+            prefix: "/blog/",
+            type: "blog",
+            position: "header",
+        };
+        const text = renderSectionIndex({
+            config: { sections: [blog] },
+            section: blog,
+            articles: [
+                { path: "/intro/", title: "Intro" },
+                { path: "/blog/old/", title: "Old", date: "2026-01-01" },
+                { path: "/blog/new/", title: "New", date: "2026-02-01", description: "Fresh" },
+            ],
+        });
+        expect(text).toBe("# Blog\n\n- [New](/blog/new/index.md): Fresh\n- [Old](/blog/old/index.md)\n");
+    });
+});
+describe("renderMarkdownTwin", () => {
+    it("leads with the title and description instead of the body's own h1", () => {
+        const twin = renderMarkdownTwin({
+            article: { path: "/intro/", title: "Introduction", description: "Start here" },
+            content: "# Livemark\n\nBody text\n",
+        });
+        expect(twin).toBe("# Introduction\n\n> Start here\n\nBody text\n");
+    });
+});
+describe("buildTwinFileName", () => {
+    it("places the twin beside the page's index.html", () => {
+        expect(buildTwinFileName("/")).toBe("index.md");
+        expect(buildTwinFileName("/guide/deep/")).toBe("guide/deep/index.md");
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"llms.unit.js","sourceRoot":"","sources":["../../source/helpers/llms.unit.ts"],"names":[],"mappings":"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","sourcesContent":["import { describe, expect, it } from \"vite-plus/test\"\nimport type { RoutedSection } from \"../models/section.ts\"\nimport {\n  buildTwinFileName,\n  renderLlmsText,\n  renderMarkdownTwin,\n  renderSectionIndex,\n} from \"./llms.ts\"\n\nconst config = { title: \"Docs\", description: \"Blurb\" }\n\ndescribe(\"renderLlmsText\", () => {\n  it(\"lists articles in sidebar order under a single heading without sections\", () => {\n    const text = renderLlmsText({\n      config,\n      articles: [\n        { path: \"/guide/\", title: \"Guide\", order: 2 },\n        { path: \"/intro/\", title: \"Intro\", description: \"Start here\", order: 1 },\n        { path: \"/guide/deep/\", title: \"Deep\" },\n      ],\n    })\n    expect(text).toBe(\n      [\n        \"# Docs\",\n        \"\",\n        \"> Blurb\",\n        \"\",\n        \"## Pages\",\n        \"\",\n        \"- [Intro](/intro/index.md): Start here\",\n        \"- [Guide](/guide/index.md)\",\n        \"- [Deep](/guide/deep/index.md)\",\n        \"\",\n      ].join(\"\\n\"),\n    )\n  })\n\n  it(\"groups by routed section, newest first in a blog, with absolute urls\", () => {\n    const text = renderLlmsText({\n      config: {\n        ...config,\n        site: \"https://example.com/\",\n        base: \"/repo\",\n        sections: [\n          { title: \"Docs\", prefix: \"/\", type: \"article\", position: \"header\" },\n          { title: \"Blog\", prefix: \"/blog/\", type: \"blog\", position: \"header\" },\n          {\n            title: \"GitHub\",\n            url: \"https://github.com\",\n            type: \"custom\",\n            position: \"header\",\n          },\n        ],\n      },\n      articles: [\n        { path: \"/blog/old/\", title: \"Old\", date: \"2026-01-01\" },\n        { path: \"/intro/\", title: \"Intro\" },\n        { path: \"/blog/new/\", title: \"New\", date: \"2026-02-01\" },\n      ],\n    })\n    expect(text).toContain(\n      [\n        \"## Docs\",\n        \"\",\n        \"- [Intro](https://example.com/repo/intro/index.md)\",\n        \"\",\n        \"## Blog\",\n        \"\",\n        \"- [New](https://example.com/repo/blog/new/index.md)\",\n        \"- [Old](https://example.com/repo/blog/old/index.md)\",\n      ].join(\"\\n\"),\n    )\n    expect(text).not.toContain(\"GitHub\")\n  })\n})\n\ndescribe(\"renderSectionIndex\", () => {\n  it(\"lists only the section's articles, newest first\", () => {\n    const blog: RoutedSection = {\n      title: \"Blog\",\n      prefix: \"/blog/\",\n      type: \"blog\",\n      position: \"header\",\n    }\n    const text = renderSectionIndex({\n      config: { sections: [blog] },\n      section: blog,\n      articles: [\n        { path: \"/intro/\", title: \"Intro\" },\n        { path: \"/blog/old/\", title: \"Old\", date: \"2026-01-01\" },\n        { path: \"/blog/new/\", title: \"New\", date: \"2026-02-01\", description: \"Fresh\" },\n      ],\n    })\n    expect(text).toBe(\n      \"# Blog\\n\\n- [New](/blog/new/index.md): Fresh\\n- [Old](/blog/old/index.md)\\n\",\n    )\n  })\n})\n\ndescribe(\"renderMarkdownTwin\", () => {\n  it(\"leads with the title and description instead of the body's own h1\", () => {\n    const twin = renderMarkdownTwin({\n      article: { path: \"/intro/\", title: \"Introduction\", description: \"Start here\" },\n      content: \"# Livemark\\n\\nBody text\\n\",\n    })\n    expect(twin).toBe(\"# Introduction\\n\\n> Start here\\n\\nBody text\\n\")\n  })\n})\n\ndescribe(\"buildTwinFileName\", () => {\n  it(\"places the twin beside the page's index.html\", () => {\n    expect(buildTwinFileName(\"/\")).toBe(\"index.md\")\n    expect(buildTwinFileName(\"/guide/deep/\")).toBe(\"guide/deep/index.md\")\n  })\n})\n"]}

package/build/helpers/nav-items.d.ts

@@ -0,0 +1,11 @@
+export type NavItem = {
+    key: string;
+    title: string;
+    icon?: string;
+    suffix?: string;
+    active: boolean;
+    href?: string;
+    target?: string;
+};
+export declare function useNavItems(activePrefix?: string): NavItem[];
+export declare function renderNavAnchor(item: NavItem, className?: string): import("react").JSX.Element;