livemark 0.25.0 → 0.26.0

package/build/helpers/head.js

@@ -0,0 +1,69 @@
+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 }] : [],
+    };
+}
+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: url ? [{ rel: \"canonical\", href: url }] : [],\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,108 @@
+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([]);
+    });
+    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":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,gBAAgB,CAAA;AAErD,OAAO,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,WAAW,CAAA;AAExD,MAAM,MAAM,GAAkB,EAAE,KAAK,EAAE,MAAM,EAAE,WAAW,EAAE,OAAO,EAAE,CAAA;AAErE,QAAQ,CAAC,eAAe,EAAE,GAAG,EAAE;IAC7B,EAAE,CAAC,8BAA8B,EAAE,GAAG,EAAE;QACtC,MAAM,IAAI,GAAG,aAAa,CAAC;YACzB,MAAM;YACN,cAAc,EAAE,WAAW;YAC3B,WAAW,EAAE,CAAC,QAAQ,CAAC;SACxB,CAAC,CAAA;QACF,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,cAAc,CAAC,EAAE,QAAQ,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,EAAE,CAAC,CAAA;QAC3E,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,cAAc,CAAC;YAChC,GAAG,EAAE,MAAM;YACX,IAAI,EAAE,WAAW;YACjB,IAAI,EAAE,eAAe;SACtB,CAAC,CAAA;QACF,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,cAAc,CAAC,EAAE,GAAG,EAAE,YAAY,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC,CAAA;QACxE,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,CAAA;IACtC,CAAC,CAAC,CAAA;IAEF,EAAE,CAAC,6CAA6C,EAAE,GAAG,EAAE;QACrD,MAAM,IAAI,GAAG,aAAa,CAAC;YACzB,MAAM,EAAE;gBACN,GAAG,MAAM;gBACT,IAAI,EAAE;oBACJ,IAAI,EAAE,CAAC,EAAE,QAAQ,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,EAAE,CAAC;oBAChD,KAAK,EAAE,CAAC,EAAE,GAAG,EAAE,IAAI,EAAE,IAAI,EAAE,kBAAkB,EAAE,CAAC;oBAChD,OAAO,EAAE,CAAC,EAAE,GAAG,EAAE,8BAA8B,EAAE,CAAC;iBACnD;aACF;YACD,cAAc,EAAE,WAAW;YAC3B,WAAW,EAAE,EAAE;SAChB,CAAC,CAAA;QACF,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,EAAE,QAAQ,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,EAAE,CAAC,CAAA;QAC1E,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,EAAE,GAAG,EAAE,IAAI,EAAE,IAAI,EAAE,kBAAkB,EAAE,CAAC,CAAA;QAC1E,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,EAAE,GAAG,EAAE,8BAA8B,EAAE,CAAC,CAAA;IAC9E,CAAC,CAAC,CAAA;IAEF,EAAE,CAAC,wCAAwC,EAAE,GAAG,EAAE;QAChD,MAAM,QAAQ,GAA8B;YAC1C,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,QAAQ,EAAE,QAAQ,EAAE;SACtE,CAAA;QACD,MAAM,WAAW,GAAG,aAAa,CAAC;YAChC,MAAM,EAAE,EAAE,GAAG,MAAM,EAAE,QAAQ,EAAE;YAC/B,cAAc,EAAE,WAAW;YAC3B,WAAW,EAAE,EAAE;SAChB,CAAC,CAAA;QACF,MAAM,QAAQ,GAAG,aAAa,CAAC;YAC7B,MAAM,EAAE,EAAE,GAAG,MAAM,EAAE,QAAQ,EAAE,IAAI,EAAE,qBAAqB,EAAE,IAAI,EAAE,OAAO,EAAE;YAC3E,cAAc,EAAE,WAAW;YAC3B,WAAW,EAAE,EAAE;SAChB,CAAC,CAAA;QACF,MAAM,CAAC,WAAW,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,KAAK,WAAW,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;QACtE,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,cAAc,CAAC;YACpC,GAAG,EAAE,WAAW;YAChB,IAAI,EAAE,qBAAqB;YAC3B,KAAK,EAAE,eAAe;YACtB,IAAI,EAAE,oBAAoB;SAC3B,CAAC,CAAA;IACJ,CAAC,CAAC,CAAA;AACJ,CAAC,CAAC,CAAA;AAEF,QAAQ,CAAC,eAAe,EAAE,GAAG,EAAE;IAC7B,EAAE,CAAC,2CAA2C,EAAE,GAAG,EAAE;QACnD,MAAM,IAAI,GAAG,aAAa,CAAC;YACzB,MAAM;YACN,IAAI,EAAE,SAAS;YACf,KAAK,EAAE,OAAO;YACd,WAAW,EAAE,QAAQ;YACrB,SAAS,EAAE,IAAI;SAChB,CAAC,CAAA;QACF,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,OAAO,CAAC;YACxB,EAAE,KAAK,EAAE,OAAO,EAAE;YAClB,EAAE,QAAQ,EAAE,UAAU,EAAE,OAAO,EAAE,OAAO,EAAE;YAC1C,EAAE,IAAI,EAAE,aAAa,EAAE,OAAO,EAAE,QAAQ,EAAE;YAC1C,EAAE,QAAQ,EAAE,gBAAgB,EAAE,OAAO,EAAE,QAAQ,EAAE;YACjD,EAAE,QAAQ,EAAE,SAAS,EAAE,OAAO,EAAE,SAAS,EAAE;SAC5C,CAAC,CAAA;QACF,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,OAAO,CAAC,EAAE,CAAC,CAAA;IAChC,CAAC,CAAC,CAAA;IAEF,EAAE,CAAC,yDAAyD,EAAE,GAAG,EAAE;QACjE,MAAM,IAAI,GAAG,aAAa,CAAC;YACzB,MAAM,EAAE,EAAE,GAAG,MAAM,EAAE,IAAI,EAAE,sBAAsB,EAAE,IAAI,EAAE,OAAO,EAAE;YAClE,IAAI,EAAE,SAAS;YACf,KAAK,EAAE,wBAAwB;SAChC,CAAC,CAAA;QACF,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,OAAO,CAAC;YACxB,EAAE,QAAQ,EAAE,QAAQ,EAAE,OAAO,EAAE,iCAAiC,EAAE;YAClE,EAAE,QAAQ,EAAE,UAAU,EAAE,OAAO,EAAE,2CAA2C,EAAE;SAC/E,CAAC,CAAA;QACF,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,OAAO,CAAC;YACzB,EAAE,GAAG,EAAE,WAAW,EAAE,IAAI,EAAE,iCAAiC,EAAE;SAC9D,CAAC,CAAA;IACJ,CAAC,CAAC,CAAA;IAEF,EAAE,CAAC,iCAAiC,EAAE,GAAG,EAAE;QACzC,MAAM,IAAI,GAAG,aAAa,CAAC;YACzB,MAAM,EAAE,EAAE,GAAG,MAAM,EAAE,IAAI,EAAE,qBAAqB,EAAE;YAClD,IAAI,EAAE,GAAG;YACT,KAAK,EAAE,mCAAmC;SAC3C,CAAC,CAAA;QACF,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,cAAc,CAAC;YAC/B,QAAQ,EAAE,UAAU;YACpB,OAAO,EAAE,mCAAmC;SAC7C,CAAC,CAAA;IACJ,CAAC,CAAC,CAAA;IAEF,EAAE,CAAC,6BAA6B,EAAE,GAAG,EAAE;QACrC,MAAM,IAAI,GAAG,aAAa,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,GAAG,EAAE,KAAK,EAAE,YAAY,EAAE,CAAC,CAAA;QACtE,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,OAAO,CAAC,EAAE,CAAC,CAAA;IAC/B,CAAC,CAAC,CAAA;AACJ,CAAC,CAAC,CAAA","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  })\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/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;

package/build/helpers/nav-items.js

@@ -0,0 +1,65 @@
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { config } from "livemark:virtual";
+import { Link, useLocation } from "@tanstack/react-router";
+import { sectionFirstArticle, sectionFlatArticles, sortedArticles, } from "../content/article.js";
+import { DynamicIcon } from "./dynamic-icon.js";
+import { prefixUrl } from "./prefix-url.js";
+import { customSectionActive } from "./section.js";
+export function useNavItems(activePrefix) {
+    const pathname = useLocation({ select: l => l.pathname });
+    const sections = config.sections ?? [];
+    const items = sections
+        .filter(section => section.position === "header")
+        .map(section => {
+        if (section.type === "custom") {
+            return {
+                key: section.url,
+                title: section.title,
+                icon: section.icon,
+                active: customSectionActive(section.url, pathname),
+                href: section.url,
+            };
+        }
+        const suffix = section.type === "changelog" && section.version
+            ? sortedArticles.find(a => a.path === sectionFlatArticles.get(section.prefix)?.[0])?.title
+            : undefined;
+        return {
+            key: section.prefix,
+            title: section.title,
+            icon: section.icon,
+            suffix,
+            active: activePrefix === section.prefix,
+            target: section.type === "blog" || section.type === "changelog"
+                ? section.prefix
+                : sectionFirstArticle.get(section.prefix),
+        };
+    });
+    if (!sections.length) {
+        items.push({ key: "/", title: "Docs", active: true, target: "/" });
+    }
+    for (const link of config.links ?? []) {
+        if (link.position !== "header")
+            continue;
+        if (link.prefix && link.prefix !== activePrefix)
+            continue;
+        items.push({
+            key: link.url,
+            title: link.title,
+            icon: link.icon,
+            active: false,
+            href: link.url,
+        });
+    }
+    return items;
+}
+export function renderNavAnchor(item, className) {
+    const children = (_jsxs(_Fragment, { children: [item.icon && _jsx(DynamicIcon, { name: item.icon, className: "size-3.5" }), _jsxs("span", { children: [item.title, item.suffix && _jsxs("span", { className: "opacity-80", children: [" (", item.suffix, ")"] })] })] }));
+    if (item.href) {
+        return (_jsx("a", { href: prefixUrl(item.href, config.base), className: className, children: children }));
+    }
+    return (_jsx(Link, { to: item.target === "/" ? "/" : "/$", params: item.target && item.target !== "/" ? splatFor(item.target) : {}, className: className, children: children }));
+}
+function splatFor(pathname) {
+    return { _splat: pathname.replace(/^\/|\/$/g, "") };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmF2LWl0ZW1zLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc291cmNlL2hlbHBlcnMvbmF2LWl0ZW1zLnRzeCJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUEsT0FBTyxFQUFFLE1BQU0sRUFBRSxNQUFNLGtCQUFrQixDQUFBO0FBQ3pDLE9BQU8sRUFBRSxJQUFJLEVBQUUsV0FBVyxFQUFFLE1BQU0sd0JBQXdCLENBQUE7QUFDMUQsT0FBTyxFQUNMLG1CQUFtQixFQUNuQixtQkFBbUIsRUFDbkIsY0FBYyxHQUNmLE1BQU0sdUJBQXVCLENBQUE7QUFDOUIsT0FBTyxFQUFFLFdBQVcsRUFBRSxNQUFNLG1CQUFvQixDQUFBO0FBQ2hELE9BQU8sRUFBRSxTQUFTLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQTtBQUMzQyxPQUFPLEVBQUUsbUJBQW1CLEVBQUUsTUFBTSxjQUFjLENBQUE7QUFZbEQsTUFBTSxVQUFVLFdBQVcsQ0FBQyxZQUFxQjtJQUMvQyxNQUFNLFFBQVEsR0FBRyxXQUFXLENBQUMsRUFBRSxNQUFNLEVBQUUsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxDQUFDLENBQUMsUUFBUSxFQUFFLENBQUMsQ0FBQTtJQUN6RCxNQUFNLFFBQVEsR0FBRyxNQUFNLENBQUMsUUFBUSxJQUFJLEVBQUUsQ0FBQTtJQUN0QyxNQUFNLEtBQUssR0FBYyxRQUFRO1NBQzlCLE1BQU0sQ0FBQyxPQUFPLENBQUMsRUFBRSxDQUFDLE9BQU8sQ0FBQyxRQUFRLEtBQUssUUFBUSxDQUFDO1NBQ2hELEdBQUcsQ0FBQyxPQUFPLENBQUMsRUFBRTtRQUNiLElBQUksT0FBTyxDQUFDLElBQUksS0FBSyxRQUFRLEVBQUUsQ0FBQztZQUM5QixPQUFPO2dCQUNMLEdBQUcsRUFBRSxPQUFPLENBQUMsR0FBRztnQkFDaEIsS0FBSyxFQUFFLE9BQU8sQ0FBQyxLQUFLO2dCQUNwQixJQUFJLEVBQUUsT0FBTyxDQUFDLElBQUk7Z0JBQ2xCLE1BQU0sRUFBRSxtQkFBbUIsQ0FBQyxPQUFPLENBQUMsR0FBRyxFQUFFLFFBQVEsQ0FBQztnQkFDbEQsSUFBSSxFQUFFLE9BQU8sQ0FBQyxHQUFHO2FBQ2xCLENBQUE7UUFDSCxDQUFDO1FBQ0QsTUFBTSxNQUFNLEdBQ1YsT0FBTyxDQUFDLElBQUksS0FBSyxXQUFXLElBQUksT0FBTyxDQUFDLE9BQU87WUFDN0MsQ0FBQyxDQUFDLGNBQWMsQ0FBQyxJQUFJLENBQ2pCLENBQUMsQ0FBQyxFQUFFLENBQUMsQ0FBQyxDQUFDLElBQUksS0FBSyxtQkFBbUIsQ0FBQyxHQUFHLENBQUMsT0FBTyxDQUFDLE1BQU0sQ0FBQyxFQUFFLENBQUMsQ0FBQyxDQUFDLENBQzdELEVBQUUsS0FBSztZQUNWLENBQUMsQ0FBQyxTQUFTLENBQUE7UUFDZixPQUFPO1lBQ0wsR0FBRyxFQUFFLE9BQU8sQ0FBQyxNQUFNO1lBQ25CLEtBQUssRUFBRSxPQUFPLENBQUMsS0FBSztZQUNwQixJQUFJLEVBQUUsT0FBTyxDQUFDLElBQUk7WUFDbEIsTUFBTTtZQUNOLE1BQU0sRUFBRSxZQUFZLEtBQUssT0FBTyxDQUFDLE1BQU07WUFDdkMsTUFBTSxFQUNKLE9BQU8sQ0FBQyxJQUFJLEtBQUssTUFBTSxJQUFJLE9BQU8sQ0FBQyxJQUFJLEtBQUssV0FBVztnQkFDckQsQ0FBQyxDQUFDLE9BQU8sQ0FBQyxNQUFNO2dCQUNoQixDQUFDLENBQUMsbUJBQW1CLENBQUMsR0FBRyxDQUFDLE9BQU8sQ0FBQyxNQUFNLENBQUM7U0FDOUMsQ0FBQTtJQUNILENBQUMsQ0FBQyxDQUFBO0lBQ0osSUFBSSxDQUFDLFFBQVEsQ0FBQyxNQUFNLEVBQUUsQ0FBQztRQUNyQixLQUFLLENBQUMsSUFBSSxDQUFDLEVBQUUsR0FBRyxFQUFFLEdBQUcsRUFBRSxLQUFLLEVBQUUsTUFBTSxFQUFFLE1BQU0sRUFBRSxJQUFJLEVBQUUsTUFBTSxFQUFFLEdBQUcsRUFBRSxDQUFDLENBQUE7SUFDcEUsQ0FBQztJQUNELEtBQUssTUFBTSxJQUFJLElBQUksTUFBTSxDQUFDLEtBQUssSUFBSSxFQUFFLEVBQUUsQ0FBQztRQUN0QyxJQUFJLElBQUksQ0FBQyxRQUFRLEtBQUssUUFBUTtZQUFFLFNBQVE7UUFDeEMsSUFBSSxJQUFJLENBQUMsTUFBTSxJQUFJLElBQUksQ0FBQyxNQUFNLEtBQUssWUFBWTtZQUFFLFNBQVE7UUFDekQsS0FBSyxDQUFDLElBQUksQ0FBQztZQUNULEdBQUcsRUFBRSxJQUFJLENBQUMsR0FBRztZQUNiLEtBQUssRUFBRSxJQUFJLENBQUMsS0FBSztZQUNqQixJQUFJLEVBQUUsSUFBSSxDQUFDLElBQUk7WUFDZixNQUFNLEVBQUUsS0FBSztZQUNiLElBQUksRUFBRSxJQUFJLENBQUMsR0FBRztTQUNmLENBQUMsQ0FBQTtJQUNKLENBQUM7SUFDRCxPQUFPLEtBQUssQ0FBQTtBQUNkLENBQUM7QUFFRCxNQUFNLFVBQVUsZUFBZSxDQUFDLElBQWEsRUFBRSxTQUFrQjtJQUMvRCxNQUFNLFFBQVEsR0FBRyxDQUNmLDhCQUNHLElBQUksQ0FBQyxJQUFJLElBQUksS0FBQyxXQUFXLElBQUMsSUFBSSxFQUFFLElBQUksQ0FBQyxJQUFJLEVBQUUsU0FBUyxFQUFDLFVBQVUsR0FBRyxFQUNuRSwyQkFDRyxJQUFJLENBQUMsS0FBSyxFQUNWLElBQUksQ0FBQyxNQUFNLElBQUksZ0JBQU0sU0FBUyxFQUFDLFlBQVksbUJBQUksSUFBSSxDQUFDLE1BQU0sU0FBUyxJQUMvRCxJQUNOLENBQ0osQ0FBQTtJQUNELElBQUksSUFBSSxDQUFDLElBQUksRUFBRSxDQUFDO1FBQ2QsT0FBTyxDQUNMLFlBQUcsSUFBSSxFQUFFLFNBQVMsQ0FBQyxJQUFJLENBQUMsSUFBSSxFQUFFLE1BQU0sQ0FBQyxJQUFJLENBQUMsRUFBRSxTQUFTLEVBQUUsU0FBUyxZQUM3RCxRQUFRLEdBQ1AsQ0FDTCxDQUFBO0lBQ0gsQ0FBQztJQUNELE9BQU8sQ0FDTCxLQUFDLElBQUksSUFDSCxFQUFFLEVBQUUsSUFBSSxDQUFDLE1BQU0sS0FBSyxHQUFHLENBQUMsQ0FBQyxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUMsSUFBSSxFQUNwQyxNQUFNLEVBQUUsSUFBSSxDQUFDLE1BQU0sSUFBSSxJQUFJLENBQUMsTUFBTSxLQUFLLEdBQUcsQ0FBQyxDQUFDLENBQUMsUUFBUSxDQUFDLElBQUksQ0FBQyxNQUFNLENBQUMsQ0FBQyxDQUFDLENBQUMsRUFBRSxFQUN2RSxTQUFTLEVBQUUsU0FBUyxZQUVuQixRQUFRLEdBQ0osQ0FDUixDQUFBO0FBQ0gsQ0FBQztBQUVELFNBQVMsUUFBUSxDQUFDLFFBQWdCO0lBQ2hDLE9BQU8sRUFBRSxNQUFNLEVBQUUsUUFBUSxDQUFDLE9BQU8sQ0FBQyxVQUFVLEVBQUUsRUFBRSxDQUFDLEVBQUUsQ0FBQTtBQUNyRCxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgY29uZmlnIH0gZnJvbSBcImxpdmVtYXJrOnZpcnR1YWxcIlxuaW1wb3J0IHsgTGluaywgdXNlTG9jYXRpb24gfSBmcm9tIFwiQHRhbnN0YWNrL3JlYWN0LXJvdXRlclwiXG5pbXBvcnQge1xuICBzZWN0aW9uRmlyc3RBcnRpY2xlLFxuICBzZWN0aW9uRmxhdEFydGljbGVzLFxuICBzb3J0ZWRBcnRpY2xlcyxcbn0gZnJvbSBcIi4uL2NvbnRlbnQvYXJ0aWNsZS50c1wiXG5pbXBvcnQgeyBEeW5hbWljSWNvbiB9IGZyb20gXCIuL2R5bmFtaWMtaWNvbi50c3hcIlxuaW1wb3J0IHsgcHJlZml4VXJsIH0gZnJvbSBcIi4vcHJlZml4LXVybC50c1wiXG5pbXBvcnQgeyBjdXN0b21TZWN0aW9uQWN0aXZlIH0gZnJvbSBcIi4vc2VjdGlvbi50c1wiXG5cbmV4cG9ydCB0eXBlIE5hdkl0ZW0gPSB7XG4gIGtleTogc3RyaW5nXG4gIHRpdGxlOiBzdHJpbmdcbiAgaWNvbj86IHN0cmluZ1xuICBzdWZmaXg/OiBzdHJpbmdcbiAgYWN0aXZlOiBib29sZWFuXG4gIGhyZWY/OiBzdHJpbmdcbiAgdGFyZ2V0Pzogc3RyaW5nXG59XG5cbmV4cG9ydCBmdW5jdGlvbiB1c2VOYXZJdGVtcyhhY3RpdmVQcmVmaXg/OiBzdHJpbmcpIHtcbiAgY29uc3QgcGF0aG5hbWUgPSB1c2VMb2NhdGlvbih7IHNlbGVjdDogbCA9PiBsLnBhdGhuYW1lIH0pXG4gIGNvbnN0IHNlY3Rpb25zID0gY29uZmlnLnNlY3Rpb25zID8/IFtdXG4gIGNvbnN0IGl0ZW1zOiBOYXZJdGVtW10gPSBzZWN0aW9uc1xuICAgIC5maWx0ZXIoc2VjdGlvbiA9PiBzZWN0aW9uLnBvc2l0aW9uID09PSBcImhlYWRlclwiKVxuICAgIC5tYXAoc2VjdGlvbiA9PiB7XG4gICAgICBpZiAoc2VjdGlvbi50eXBlID09PSBcImN1c3RvbVwiKSB7XG4gICAgICAgIHJldHVybiB7XG4gICAgICAgICAga2V5OiBzZWN0aW9uLnVybCxcbiAgICAgICAgICB0aXRsZTogc2VjdGlvbi50aXRsZSxcbiAgICAgICAgICBpY29uOiBzZWN0aW9uLmljb24sXG4gICAgICAgICAgYWN0aXZlOiBjdXN0b21TZWN0aW9uQWN0aXZlKHNlY3Rpb24udXJsLCBwYXRobmFtZSksXG4gICAgICAgICAgaHJlZjogc2VjdGlvbi51cmwsXG4gICAgICAgIH1cbiAgICAgIH1cbiAgICAgIGNvbnN0IHN1ZmZpeCA9XG4gICAgICAgIHNlY3Rpb24udHlwZSA9PT0gXCJjaGFuZ2Vsb2dcIiAmJiBzZWN0aW9uLnZlcnNpb25cbiAgICAgICAgICA/IHNvcnRlZEFydGljbGVzLmZpbmQoXG4gICAgICAgICAgICAgIGEgPT4gYS5wYXRoID09PSBzZWN0aW9uRmxhdEFydGljbGVzLmdldChzZWN0aW9uLnByZWZpeCk/LlswXSxcbiAgICAgICAgICAgICk/LnRpdGxlXG4gICAgICAgICAgOiB1bmRlZmluZWRcbiAgICAgIHJldHVybiB7XG4gICAgICAgIGtleTogc2VjdGlvbi5wcmVmaXgsXG4gICAgICAgIHRpdGxlOiBzZWN0aW9uLnRpdGxlLFxuICAgICAgICBpY29uOiBzZWN0aW9uLmljb24sXG4gICAgICAgIHN1ZmZpeCxcbiAgICAgICAgYWN0aXZlOiBhY3RpdmVQcmVmaXggPT09IHNlY3Rpb24ucHJlZml4LFxuICAgICAgICB0YXJnZXQ6XG4gICAgICAgICAgc2VjdGlvbi50eXBlID09PSBcImJsb2dcIiB8fCBzZWN0aW9uLnR5cGUgPT09IFwiY2hhbmdlbG9nXCJcbiAgICAgICAgICAgID8gc2VjdGlvbi5wcmVmaXhcbiAgICAgICAgICAgIDogc2VjdGlvbkZpcnN0QXJ0aWNsZS5nZXQoc2VjdGlvbi5wcmVmaXgpLFxuICAgICAgfVxuICAgIH0pXG4gIGlmICghc2VjdGlvbnMubGVuZ3RoKSB7XG4gICAgaXRlbXMucHVzaCh7IGtleTogXCIvXCIsIHRpdGxlOiBcIkRvY3NcIiwgYWN0aXZlOiB0cnVlLCB0YXJnZXQ6IFwiL1wiIH0pXG4gIH1cbiAgZm9yIChjb25zdCBsaW5rIG9mIGNvbmZpZy5saW5rcyA/PyBbXSkge1xuICAgIGlmIChsaW5rLnBvc2l0aW9uICE9PSBcImhlYWRlclwiKSBjb250aW51ZVxuICAgIGlmIChsaW5rLnByZWZpeCAmJiBsaW5rLnByZWZpeCAhPT0gYWN0aXZlUHJlZml4KSBjb250aW51ZVxuICAgIGl0ZW1zLnB1c2goe1xuICAgICAga2V5OiBsaW5rLnVybCxcbiAgICAgIHRpdGxlOiBsaW5rLnRpdGxlLFxuICAgICAgaWNvbjogbGluay5pY29uLFxuICAgICAgYWN0aXZlOiBmYWxzZSxcbiAgICAgIGhyZWY6IGxpbmsudXJsLFxuICAgIH0pXG4gIH1cbiAgcmV0dXJuIGl0ZW1zXG59XG5cbmV4cG9ydCBmdW5jdGlvbiByZW5kZXJOYXZBbmNob3IoaXRlbTogTmF2SXRlbSwgY2xhc3NOYW1lPzogc3RyaW5nKSB7XG4gIGNvbnN0IGNoaWxkcmVuID0gKFxuICAgIDw+XG4gICAgICB7aXRlbS5pY29uICYmIDxEeW5hbWljSWNvbiBuYW1lPXtpdGVtLmljb259IGNsYXNzTmFtZT1cInNpemUtMy41XCIgLz59XG4gICAgICA8c3Bhbj5cbiAgICAgICAge2l0ZW0udGl0bGV9XG4gICAgICAgIHtpdGVtLnN1ZmZpeCAmJiA8c3BhbiBjbGFzc05hbWU9XCJvcGFjaXR5LTgwXCI+ICh7aXRlbS5zdWZmaXh9KTwvc3Bhbj59XG4gICAgICA8L3NwYW4+XG4gICAgPC8+XG4gIClcbiAgaWYgKGl0ZW0uaHJlZikge1xuICAgIHJldHVybiAoXG4gICAgICA8YSBocmVmPXtwcmVmaXhVcmwoaXRlbS5ocmVmLCBjb25maWcuYmFzZSl9IGNsYXNzTmFtZT17Y2xhc3NOYW1lfT5cbiAgICAgICAge2NoaWxkcmVufVxuICAgICAgPC9hPlxuICAgIClcbiAgfVxuICByZXR1cm4gKFxuICAgIDxMaW5rXG4gICAgICB0bz17aXRlbS50YXJnZXQgPT09IFwiL1wiID8gXCIvXCIgOiBcIi8kXCJ9XG4gICAgICBwYXJhbXM9e2l0ZW0udGFyZ2V0ICYmIGl0ZW0udGFyZ2V0ICE9PSBcIi9cIiA/IHNwbGF0Rm9yKGl0ZW0udGFyZ2V0KSA6IHt9fVxuICAgICAgY2xhc3NOYW1lPXtjbGFzc05hbWV9XG4gICAgPlxuICAgICAge2NoaWxkcmVufVxuICAgIDwvTGluaz5cbiAgKVxufVxuXG5mdW5jdGlvbiBzcGxhdEZvcihwYXRobmFtZTogc3RyaW5nKSB7XG4gIHJldHVybiB7IF9zcGxhdDogcGF0aG5hbWUucmVwbGFjZSgvXlxcL3xcXC8kL2csIFwiXCIpIH1cbn1cbiJdfQ==

package/build/helpers/render-inline-markdown.d.ts

@@ -0,0 +1 @@
+export declare function renderInlineMarkdown(markdown: string, base: string | undefined): string;

package/build/helpers/render-inline-markdown.js

@@ -0,0 +1,34 @@
+import rehypeStringify from "rehype-stringify";
+import remarkGfm from "remark-gfm";
+import remarkParse from "remark-parse";
+import remarkRehype from "remark-rehype";
+import { unified } from "unified";
+import { visit } from "unist-util-visit";
+import { prefixUrl } from "./prefix-url.js";
+export function renderInlineMarkdown(markdown, base) {
+    const html = unified()
+        .use(remarkParse)
+        .use(remarkGfm)
+        .use(remarkRehype)
+        .use(() => (tree) => rewriteLinks(tree, base))
+        .use(() => unwrapParagraphs)
+        .use(rehypeStringify)
+        .processSync(markdown);
+    return String(html).trim();
+}
+function rewriteLinks(tree, base) {
+    visit(tree, "element", (node) => {
+        if (node.tagName !== "a" || typeof node.properties?.href !== "string")
+            return;
+        const href = node.properties.href;
+        node.properties.href = prefixUrl(href, base);
+        if (/^https?:\/\//.test(href)) {
+            node.properties.target = "_blank";
+            node.properties.rel = ["noopener", "noreferrer"];
+        }
+    });
+}
+function unwrapParagraphs(tree) {
+    tree.children = (tree.children ?? []).flatMap(child => child.type === "element" && child.tagName === "p" ? (child.children ?? []) : [child]);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/helpers/render-inline-markdown.unit.d.ts

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

package/build/helpers/render-inline-markdown.unit.js

@@ -0,0 +1,20 @@
+import { describe, expect, it } from "vite-plus/test";
+import { renderInlineMarkdown } from "./render-inline-markdown.js";
+describe("renderInlineMarkdown", () => {
+    it("should render plain text without a paragraph", () => {
+        expect(renderInlineMarkdown("Hello world", undefined)).toBe("Hello world");
+    });
+    it("should render bold, emphasis and code", () => {
+        expect(renderInlineMarkdown("**a** _b_ `c`", undefined)).toBe("<strong>a</strong> <em>b</em> <code>c</code>");
+    });
+    it("should open absolute links in a new tab", () => {
+        expect(renderInlineMarkdown("[x](https://example.com)", undefined)).toBe('<a href="https://example.com" target="_blank" rel="noopener noreferrer">x</a>');
+    });
+    it("should prefix root-relative links with the base", () => {
+        expect(renderInlineMarkdown("[x](/blog/)", "/repo")).toBe('<a href="/repo/blog/">x</a>');
+    });
+    it("should drop raw HTML tags", () => {
+        expect(renderInlineMarkdown("a <b onclick=x>c</b>", undefined)).toBe("a c");
+    });
+});
+//# sourceMappingURL=data:application/json;base64,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

package/build/helpers/search-highlight.d.ts

@@ -0,0 +1,8 @@
+import { type RefObject } from "react";
+/** Build a case-insensitive pattern matching each word of a search query */
+export declare function buildHighlightPattern(query: string): RegExp | undefined;
+/** Find the `[start, end]` offsets of every pattern match in a text */
+export declare function findTextMatches(text: string, pattern: RegExp): (readonly [number, number])[];
+/** Highlight search query matches under `root` and scroll to the first visible one;
+ *  `page` re-runs it when the same query lands on another page */
+export declare function useSearchHighlight(root: RefObject<HTMLElement | null>, page: string, query?: string): void;

package/build/helpers/search-highlight.js

@@ -0,0 +1,59 @@
+import { useEffect } from "react";
+const HIGHLIGHT_NAME = "search-match";
+/** Build a case-insensitive pattern matching each word of a search query */
+export function buildHighlightPattern(query) {
+    const words = [...new Set(query.toLowerCase().split(/\s+/))]
+        .filter(word => word.length >= 2)
+        .sort((a, b) => b.length - a.length)
+        .map(word => word.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"));
+    if (!words.length)
+        return undefined;
+    return new RegExp(words.join("|"), "gi");
+}
+/** Find the `[start, end]` offsets of every pattern match in a text */
+export function findTextMatches(text, pattern) {
+    return [...text.matchAll(pattern)].map(match => [match.index, match.index + match[0].length]);
+}
+/** Highlight search query matches under `root` and scroll to the first visible one;
+ *  `page` re-runs it when the same query lands on another page */
+export function useSearchHighlight(root, page, query) {
+    useEffect(() => {
+        const pattern = query ? buildHighlightPattern(query) : undefined;
+        if (!pattern || !root.current || typeof CSS === "undefined" || !CSS.highlights)
+            return;
+        const ranges = collectMatchRanges(root.current, pattern);
+        CSS.highlights.set(HIGHLIGHT_NAME, new Highlight(...ranges));
+        // An explicit anchor in the URL wins over the first match. The frame delay lets
+        // the router's scroll restoration, which resets to the top, run first.
+        const frame = window.location.hash
+            ? undefined
+            : requestAnimationFrame(() => scrollToFirstVisible(ranges));
+        return () => {
+            if (frame !== undefined)
+                cancelAnimationFrame(frame);
+            CSS.highlights.delete(HIGHLIGHT_NAME);
+        };
+    }, [root, page, query]);
+}
+function collectMatchRanges(root, pattern) {
+    const ranges = [];
+    const walker = document.createTreeWalker(root, NodeFilter.SHOW_TEXT, {
+        acceptNode: node => node.parentElement?.closest("pre, script, style, svg, textarea")
+            ? NodeFilter.FILTER_REJECT
+            : NodeFilter.FILTER_ACCEPT,
+    });
+    for (let node = walker.nextNode(); node; node = walker.nextNode()) {
+        for (const [start, end] of findTextMatches(node.textContent ?? "", pattern)) {
+            const range = new Range();
+            range.setStart(node, start);
+            range.setEnd(node, end);
+            ranges.push(range);
+        }
+    }
+    return ranges;
+}
+function scrollToFirstVisible(ranges) {
+    const first = ranges.find(range => range.startContainer.parentElement?.checkVisibility());
+    first?.startContainer.parentElement?.scrollIntoView({ block: "center" });
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/helpers/search-highlight.unit.d.ts

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

package/build/helpers/search-highlight.unit.js

@@ -0,0 +1,36 @@
+import { describe, expect, it } from "vite-plus/test";
+import { buildHighlightPattern, findTextMatches } from "./search-highlight.js";
+describe("buildHighlightPattern", () => {
+    it("should return undefined for an empty query", () => {
+        expect(buildHighlightPattern("   ")).toBeUndefined();
+    });
+    it("should drop single-character words", () => {
+        expect(buildHighlightPattern("a b")).toBeUndefined();
+        expect(buildHighlightPattern("a config")?.source).toBe("config");
+    });
+    it("should put longer words first and dedupe case-insensitively", () => {
+        expect(buildHighlightPattern("Side sidebar side")?.source).toBe("sidebar|side");
+    });
+    it("should escape regex syntax", () => {
+        expect(buildHighlightPattern("c++ (x)")?.source).toBe("c\\+\\+|\\(x\\)");
+    });
+});
+describe("findTextMatches", () => {
+    it("should find every word case-insensitively", () => {
+        const pattern = buildHighlightPattern("search config");
+        expect(pattern && findTextMatches("Search the Config, search!", pattern)).toEqual([
+            [0, 6],
+            [11, 17],
+            [19, 25],
+        ]);
+    });
+    it("should prefer the longest word at a shared position", () => {
+        const pattern = buildHighlightPattern("side sidebar");
+        expect(pattern && findTextMatches("the sidebar", pattern)).toEqual([[4, 11]]);
+    });
+    it("should return no matches when nothing matches", () => {
+        const pattern = buildHighlightPattern("orama");
+        expect(pattern && findTextMatches("nothing here", pattern)).toEqual([]);
+    });
+});
+//# sourceMappingURL=data:application/json;base64,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

package/build/helpers/target-export.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Map a `livemark/<subpath>` import onto the target copy its `exports` entry names, so
+ * escapes importing Livemark modules reach other escapes, not the package originals.
+ */
+export declare function resolveTargetExport(props: {
+    id: string;
+    targetDir: string;
+    exports: Record<string, string>;
+}): string | undefined;

package/build/helpers/target-export.js

@@ -0,0 +1,24 @@
+import { join } from "node:path";
+/**
+ * Map a `livemark/<subpath>` import onto the target copy its `exports` entry names, so
+ * escapes importing Livemark modules reach other escapes, not the package originals.
+ */
+export function resolveTargetExport(props) {
+    const queryIndex = props.id.indexOf("?");
+    const specifier = queryIndex === -1 ? props.id : props.id.slice(0, queryIndex);
+    const query = queryIndex === -1 ? "" : props.id.slice(queryIndex);
+    if (!specifier.startsWith("livemark/"))
+        return undefined;
+    const subpath = `./${specifier.slice("livemark/".length)}`;
+    for (const [key, value] of Object.entries(props.exports)) {
+        const [prefix, suffix] = key.split("*");
+        if (suffix === undefined || !prefix || !value.startsWith("./source/"))
+            continue;
+        if (!subpath.startsWith(prefix) || !subpath.endsWith(suffix))
+            continue;
+        const name = subpath.slice(prefix.length, subpath.length - suffix.length);
+        return (join(props.targetDir, value.slice("./source/".length).replace("*", name)) + query);
+    }
+    return undefined;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/helpers/target-export.unit.d.ts

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

package/build/helpers/target-export.unit.js

@@ -0,0 +1,25 @@
+import { join } from "node:path";
+import { describe, expect, it } from "vite-plus/test";
+import packageJson from "../../package.json" with { type: "json" };
+import { resolveTargetExport } from "./target-export.js";
+const targetDir = "/project/.livemark/.target";
+function resolveId(id) {
+    return resolveTargetExport({ id, targetDir, exports: packageJson.exports });
+}
+describe("resolveTargetExport", () => {
+    it("maps each source subpath export into the target", () => {
+        expect(resolveId("livemark/components/Footer")).toBe(join(targetDir, "components/Footer.tsx"));
+        expect(resolveId("livemark/elements/button")).toBe(join(targetDir, "elements/button.tsx"));
+        expect(resolveId("livemark/hooks/in-view")).toBe(join(targetDir, "hooks/in-view.ts"));
+        expect(resolveId("livemark/styles/general")).toBe(join(targetDir, "styles/general.css"));
+    });
+    it("keeps the query", () => {
+        expect(resolveId("livemark/styles/general?url")).toBe(`${join(targetDir, "styles/general.css")}?url`);
+    });
+    it("leaves other specifiers alone", () => {
+        expect(resolveId("livemark")).toBeUndefined();
+        expect(resolveId("livemark/unknown/thing")).toBeUndefined();
+        expect(resolveId("react")).toBeUndefined();
+    });
+});
+//# sourceMappingURL=data:application/json;base64,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

package/build/helpers/theme.d.ts

@@ -1,5 +1,9 @@
 export type Theme = "light" | "dark";
-export declare function detectClientTheme(): Theme;
+export type ThemePref = Theme | "system";
+export declare function resolveTheme(pref: ThemePref, prefersDark: boolean): Theme;
 export declare function activateTheme(theme: Theme): void;
 export declare function getCurrentTheme(): Theme;
-export declare function setTheme(theme: Theme): void;
+export declare function getThemePref(): ThemePref;
+export declare function setTheme(pref: ThemePref): void;
+export declare function startTheme(): () => void;
+export declare function buildThemeScript(): string;