@takazudo/zudo-doc 0.2.21 → 1.0.0

package/dist/footer/footer.d.ts

@@ -1,10 +1,8 @@
-import { VNode } from 'preact';
-import { FooterLinkColumn, FooterTagColumn } from './types.js';
-
 /** @jsxRuntime automatic */
 /** @jsxImportSource preact */
-
-interface FooterProps {
+import type { VNode } from "preact";
+import type { FooterLinkColumn, FooterTagColumn } from "./types.js";
+export interface FooterProps {
     /**
      * Already-localized link columns. Each item's href should be
      * base-prefixed and locale-aware; `isExternal` controls the
@@ -37,6 +35,4 @@ interface FooterProps {
  * configured. The inner content (link grid, copyright) is only emitted
  * when the respective slots carry data.
  */
-declare function Footer(props: FooterProps): VNode;
-
-export { Footer, type FooterProps };
+export declare function Footer(props: FooterProps): VNode;

package/dist/footer/index.d.ts

@@ -1,3 +1,13 @@
-export { Footer, FooterProps } from './footer.js';
-export { FooterLinkColumn, FooterLinkItem, FooterTagColumn, FooterTagItem } from './types.js';
-import 'preact';
+/**
+ * Public entry for the framework-agnostic footer shell.
+ *
+ * Consumers import from `@takazudo/zudo-doc/footer`:
+ *
+ *   import { Footer, type FooterProps } from "@takazudo/zudo-doc/footer";
+ *
+ * The shell is purely presentational — see `./types.ts` for the data
+ * shapes the host project assembles upstream.
+ */
+export { Footer } from "./footer.js";
+export type { FooterProps } from "./footer.js";
+export type { FooterLinkColumn, FooterLinkItem, FooterTagColumn, FooterTagItem, } from "./types.js";

package/dist/footer/types.d.ts

@@ -14,7 +14,7 @@
  * already-localized, already-resolved hrefs in.
  */
 /** A single link rendered inside a {@link FooterLinkColumn}. */
-interface FooterLinkItem {
+export interface FooterLinkItem {
     /** Visible label (already locale-resolved by the caller). */
     label: string;
     /** Resolved href (already base-prefixed and locale-aware). */
@@ -27,13 +27,13 @@ interface FooterLinkItem {
     isExternal?: boolean;
 }
 /** One column in the footer's link grid. */
-interface FooterLinkColumn {
+export interface FooterLinkColumn {
     /** Visible heading for the column (already locale-resolved). */
     title: string;
     items: FooterLinkItem[];
 }
 /** A single tag rendered inside a {@link FooterTagColumn}. */
-interface FooterTagItem {
+export interface FooterTagItem {
     /** Canonical tag id (rendered as `#<tag>`). */
     tag: string;
     /** Document count shown next to the tag. */
@@ -42,7 +42,7 @@ interface FooterTagItem {
     href: string;
 }
 /** One column in the footer's tag grid. */
-interface FooterTagColumn {
+export interface FooterTagColumn {
     /**
      * Group identifier — usually a vocabulary group name like `"topic"`,
      * or the literal `"__flat__"` sentinel for the ungrouped/flat column.
@@ -54,5 +54,3 @@ interface FooterTagColumn {
     title: string;
     tags: FooterTagItem[];
 }
-
-export type { FooterLinkColumn, FooterLinkItem, FooterTagColumn, FooterTagItem };

package/dist/footer-with-defaults/index.d.ts

@@ -0,0 +1,63 @@
+/** @jsxRuntime automatic */
+/** @jsxImportSource preact */
+import type { VNode } from "preact";
+/** Tag info returned by the host's `collectTags` (what the factory sees). */
+export interface FooterTagInfo {
+    tag: string;
+    count: number;
+}
+/** Tag vocabulary entry subset the factory reads. */
+export interface FooterVocabularyEntry {
+    id: string;
+    group?: string;
+}
+/** The `settings.footer` subset the factory reads. */
+export interface FooterConfig {
+    links: Array<{
+        title: string;
+        locales?: Record<string, {
+            title: string;
+        } | undefined>;
+        items: Array<{
+            label: string;
+            href: string;
+            locales?: Record<string, {
+                label: string;
+            } | undefined>;
+        }>;
+    }>;
+    copyright?: string;
+    taglist?: {
+        enabled?: boolean;
+        groupBy?: "flat" | "group";
+        title?: string;
+        groupTitles?: Record<string, string>;
+        locales?: Record<string, {
+            title?: string;
+            groupTitles?: Record<string, string>;
+        } | undefined>;
+    };
+}
+/** Settings subset read by {@link createFooterWithDefaults}. */
+export interface FooterWithDefaultsSettings {
+    footer?: FooterConfig | false | null;
+    tagVocabulary?: unknown;
+    tagGovernance?: string;
+}
+/** Dependencies injected by the host stub. */
+export interface FooterWithDefaultsDeps {
+    settings: FooterWithDefaultsSettings;
+    defaultLocale: string;
+    tagVocabulary: readonly FooterVocabularyEntry[];
+    isExternal: (href: string) => boolean;
+    resolveHref: (href: string) => string;
+    withBase: (path: string) => string;
+    loadTagsForLocale: (lang: string) => FooterTagInfo[];
+}
+/**
+ * Create a `FooterWithDefaults` component bound to the host's settings
+ * and data-prep utilities.
+ */
+export declare function createFooterWithDefaults(deps: FooterWithDefaultsDeps): (props: {
+    lang?: string;
+}) => VNode;

package/dist/footer-with-defaults/index.js

@@ -0,0 +1,128 @@
+import { jsx } from "preact/jsx-runtime";
+import { Footer } from "../footer/index.js";
+function createFooterWithDefaults(deps) {
+  const {
+    settings,
+    defaultLocale,
+    tagVocabulary,
+    isExternal,
+    resolveHref,
+    withBase,
+    loadTagsForLocale
+  } = deps;
+  function localizeHref(href, lang) {
+    if (isExternal(href)) return href;
+    if (lang !== defaultLocale) {
+      const path = href.startsWith("/") ? href : `/${href}`;
+      return resolveHref(`/${lang}${path}`);
+    }
+    return resolveHref(href);
+  }
+  function tagHref(tag, lang) {
+    const encoded = encodeURIComponent(tag);
+    const path = lang === defaultLocale ? `/docs/tags/${encoded}` : `/${lang}/docs/tags/${encoded}`;
+    return withBase(path);
+  }
+  function FooterWithDefaults({
+    lang = defaultLocale
+  }) {
+    const footer = settings.footer;
+    const persistKey = `footer-${lang}`;
+    if (!footer) {
+      return /* @__PURE__ */ jsx(Footer, { persistKey });
+    }
+    const { links, copyright, taglist } = footer;
+    const linkColumns = links.map((column) => ({
+      title: column.locales?.[lang]?.title ?? column.title,
+      items: column.items.map((item) => ({
+        label: item.locales?.[lang]?.label ?? item.label,
+        href: localizeHref(item.href, lang),
+        isExternal: isExternal(item.href)
+      }))
+    }));
+    let tagColumns = [];
+    if (taglist?.enabled) {
+      const allTags = loadTagsForLocale(lang);
+      const vocabularyActive = Boolean(settings.tagVocabulary) && settings.tagGovernance !== "off";
+      const requestedGroupBy = taglist.groupBy ?? "group";
+      const effectiveGroupBy = vocabularyActive ? requestedGroupBy : "flat";
+      const localeOverrides = taglist.locales?.[lang];
+      const groupTitles = {
+        ...taglist.groupTitles,
+        ...localeOverrides?.groupTitles
+      };
+      const flatTitle = localeOverrides?.title ?? taglist.title ?? "Tags";
+      if (effectiveGroupBy === "flat" || !vocabularyActive) {
+        if (allTags.length > 0) {
+          tagColumns = [
+            {
+              group: "__flat__",
+              title: flatTitle,
+              tags: allTags.map(({ tag, count }) => ({
+                tag,
+                count,
+                href: tagHref(tag, lang)
+              }))
+            }
+          ];
+        }
+      } else {
+        const groupByCanonical = /* @__PURE__ */ new Map();
+        const groupOrder = [];
+        const seenGroups = /* @__PURE__ */ new Set();
+        for (const entry of tagVocabulary) {
+          if (!entry.group) continue;
+          groupByCanonical.set(entry.id, entry.group);
+          if (!seenGroups.has(entry.group)) {
+            seenGroups.add(entry.group);
+            groupOrder.push(entry.group);
+          }
+        }
+        const buckets = /* @__PURE__ */ new Map();
+        for (const group of groupOrder) buckets.set(group, []);
+        const ungrouped = [];
+        for (const info of allTags) {
+          const group = groupByCanonical.get(info.tag);
+          if (group && buckets.has(group)) {
+            buckets.get(group).push(info);
+          } else {
+            ungrouped.push(info);
+          }
+        }
+        tagColumns = groupOrder.filter((g) => (buckets.get(g)?.length ?? 0) > 0).map((g) => ({
+          group: g,
+          title: groupTitles[g] ?? g.charAt(0).toUpperCase() + g.slice(1),
+          tags: buckets.get(g).map(({ tag, count }) => ({
+            tag,
+            count,
+            href: tagHref(tag, lang)
+          }))
+        }));
+        if (ungrouped.length > 0) {
+          tagColumns.push({
+            group: "__flat__",
+            title: flatTitle,
+            tags: ungrouped.map(({ tag, count }) => ({
+              tag,
+              count,
+              href: tagHref(tag, lang)
+            }))
+          });
+        }
+      }
+    }
+    return /* @__PURE__ */ jsx(
+      Footer,
+      {
+        linkColumns,
+        tagColumns,
+        copyright,
+        persistKey
+      }
+    );
+  }
+  return FooterWithDefaults;
+}
+export {
+  createFooterWithDefaults
+};

package/dist/frontmatter-preview-data/index.d.ts

@@ -0,0 +1,26 @@
+import type { FrontmatterPreviewConfig } from "../settings.js";
+export type { FrontmatterPreviewConfig };
+/**
+ * Config the factory reads from the host's settings.
+ *
+ * `frontmatterPreview` is the host's resolved `settings.frontmatterPreview`
+ * field (a `FrontmatterPreviewConfig` object or `false`/`undefined`).
+ * `defaultIgnoreKeys` is the host-supplied schema-managed key list
+ * (typically `DEFAULT_FRONTMATTER_IGNORE_KEYS` from the host's config).
+ */
+export interface FrontmatterPreviewDataConfig {
+    frontmatterPreview: FrontmatterPreviewConfig | false | undefined;
+    defaultIgnoreKeys: readonly string[];
+}
+/**
+ * Create a `buildFrontmatterPreviewEntries` helper bound to the given config.
+ *
+ * The host stub calls this once with its concrete settings and re-exports the
+ * result, mirroring the shape of `makeUrlHelpers` (S1a) and
+ * `createComposeMetaTitle`.
+ *
+ * Returning an empty array suppresses the frontmatter block — the v2
+ * `<FrontmatterPreview>` component short-circuits with `null` when
+ * `entries` is empty.
+ */
+export declare function createBuildFrontmatterPreviewEntries(config: FrontmatterPreviewDataConfig): (data: Record<string, unknown> | null | undefined) => Array<[string, unknown]>;

package/dist/frontmatter-preview-data/index.js

@@ -0,0 +1,23 @@
+function createBuildFrontmatterPreviewEntries(config) {
+  return function buildFrontmatterPreviewEntries(data) {
+    if (!data) return [];
+    const fmConfig = config.frontmatterPreview;
+    if (fmConfig === false || fmConfig === void 0) return [];
+    const ignoreSet = new Set(
+      fmConfig.ignoreKeys ?? [
+        ...config.defaultIgnoreKeys,
+        ...fmConfig.extraIgnoreKeys ?? []
+      ]
+    );
+    const entries = [];
+    for (const [key, value] of Object.entries(data)) {
+      if (ignoreSet.has(key)) continue;
+      if (value === null || value === void 0) continue;
+      entries.push([key, value]);
+    }
+    return entries;
+  };
+}
+export {
+  createBuildFrontmatterPreviewEntries
+};

package/dist/github-helpers/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Build the GitHub repository root URL, or null if githubUrl is not configured.
+ *
+ * Parameterized version of the host's `buildGitHubRepoUrl()`.
+ */
+export declare function buildGitHubRepoUrl(githubUrl: string | false | null | undefined): string | null;
+/**
+ * Build a view-source GitHub URL pointing at a content file, or null when
+ * githubUrl is not set.
+ *
+ * Parameterized version of the host's `buildGitHubSourceUrl(contentDir, entryId)`.
+ *
+ * @param githubUrl  - The repository base URL (e.g. `settings.githubUrl`).
+ * @param contentDir - Content directory relative to the repo root (e.g. "src/content/docs").
+ * @param entryId    - File path within contentDir (e.g. "getting-started/intro.mdx").
+ */
+export declare function buildGitHubSourceUrl(githubUrl: string | false | null | undefined, contentDir: string, entryId: string): string | null;

package/dist/github-helpers/index.js

@@ -0,0 +1,16 @@
+function trimTrailingSlash(url) {
+  return url.replace(/\/+$/, "");
+}
+function buildGitHubRepoUrl(githubUrl) {
+  if (!githubUrl) return null;
+  return trimTrailingSlash(githubUrl);
+}
+function buildGitHubSourceUrl(githubUrl, contentDir, entryId) {
+  const repoUrl = buildGitHubRepoUrl(githubUrl);
+  if (!repoUrl) return null;
+  return `${repoUrl}/blob/HEAD/${contentDir}/${entryId}`;
+}
+export {
+  buildGitHubRepoUrl,
+  buildGitHubSourceUrl
+};

package/dist/head/doc-head.d.ts

@@ -1,6 +1,5 @@
-import { JSX } from 'preact';
-import { HeadProps } from './types.js';
-
+import type { JSX } from "preact";
+import type { HeadProps } from "./types.js";
 /**
  * Framework head tag emission. Renders only the meta-tag layer of <head>;
  * provider components such as ColorSchemeProvider or astro:transitions'
@@ -28,6 +27,4 @@ import { HeadProps } from './types.js';
  * Never reorder existing slots; append new tag families at the end so
  * downstream byte-diffs remain stable.
  */
-declare function DocHead(props: HeadProps): JSX.Element;
-
-export { DocHead };
+export declare function DocHead(props: HeadProps): JSX.Element;

package/dist/head/index.d.ts

@@ -1,5 +1,9 @@
-export { DocHead } from './doc-head.js';
-export { OgTags } from './og-tags.js';
-export { TwitterCard } from './twitter-card.js';
-export { HeadProps } from './types.js';
-import 'preact';
+/**
+ * Public entry for the head topic. Hosts import the JSX component primitive
+ * and the input type from this module; all other files in `head/` are
+ * implementation detail.
+ */
+export { DocHead } from "./doc-head.js";
+export { OgTags } from "./og-tags.js";
+export { TwitterCard } from "./twitter-card.js";
+export type { HeadProps } from "./types.js";

package/dist/head/og-tags.d.ts

@@ -1,6 +1,5 @@
-import { JSX } from 'preact';
-import { HeadProps } from './types.js';
-
+import type { JSX } from "preact";
+import type { HeadProps } from "./types.js";
 /**
  * Open Graph meta tags. Emits og:title (always — defaults to `title`) plus
  * any other og:* fields the caller has supplied.
@@ -10,7 +9,7 @@ import { HeadProps } from './types.js';
  * New og:* tags should be appended at the end of the list, never reordered,
  * to keep snapshot diffs minimal.
  */
-declare function OgTags(props: {
+export declare function OgTags(props: {
     title: string;
     description?: string;
     ogTitle?: string;
@@ -20,6 +19,4 @@ declare function OgTags(props: {
     ogImage?: string;
     ogSiteName?: string;
 }): JSX.Element;
-type OgInputs = Pick<HeadProps, "ogTitle" | "ogDescription" | "ogType" | "ogUrl" | "ogImage" | "ogSiteName">;
-
-export { type OgInputs, OgTags };
+export type OgInputs = Pick<HeadProps, "ogTitle" | "ogDescription" | "ogType" | "ogUrl" | "ogImage" | "ogSiteName">;

package/dist/head/twitter-card.d.ts

@@ -1,6 +1,5 @@
-import { JSX } from 'preact';
-import { HeadProps } from './types.js';
-
+import type { JSX } from "preact";
+import type { HeadProps } from "./types.js";
 /**
  * Twitter card meta tags. The host renders this only when a card type is
  * configured; this component itself assumes `card` is set and emits twitter:card
@@ -9,7 +8,7 @@ import { HeadProps } from './types.js';
  * Field order: card → site → creator → title → description → image. Preserve
  * this order to keep snapshot diffs predictable.
  */
-declare function TwitterCard(props: {
+export declare function TwitterCard(props: {
     card: NonNullable<HeadProps["twitterCard"]>;
     site?: string;
     creator?: string;
@@ -17,5 +16,3 @@ declare function TwitterCard(props: {
     description?: string;
     image?: string;
 }): JSX.Element;
-
-export { TwitterCard };

package/dist/head/types.d.ts

@@ -7,7 +7,7 @@
  * portable across Astro and zfb hosts and lets us assert byte-parity in
  * unit tests without bootstrapping a full runtime.
  */
-interface HeadProps {
+export interface HeadProps {
     /**
      * Full title string. The caller is responsible for composing
      * "{Page Title} | {Site Name}" — DocHead does not append the site name.
@@ -79,5 +79,3 @@ interface HeadProps {
         crossorigin?: "anonymous" | "use-credentials";
     }>;
 }
-
-export type { HeadProps };

package/dist/head-with-defaults/index.d.ts

@@ -0,0 +1,49 @@
+/** @jsxRuntime automatic */
+/** @jsxImportSource preact */
+import type { JSX } from "preact";
+import type { HeadProps } from "../head/types.js";
+import type { ColorSchemeProviderColorMode } from "../theme/color-scheme-provider.js";
+export interface HeadWithDefaultsProps {
+    /** Page title forwarded to og:title. Required. */
+    title: string;
+    /** Optional page description forwarded to og:description. */
+    description?: string;
+    /**
+     * Absolute canonical URL for this page. When supplied, emits
+     * `<link rel="canonical" href="...">`.
+     */
+    canonical?: string;
+}
+/** Settings subset read by {@link createHeadWithDefaults}. */
+export interface HeadWithDefaultsSettings {
+    metaTags: {
+        description?: boolean | null;
+        ogImage?: string | false;
+        ogSiteName?: boolean;
+        keywords?: string | false;
+        twitterCard?: HeadProps["twitterCard"] | false;
+        twitterSite?: string;
+        twitterCreator?: string;
+    };
+    siteName: string;
+    colorMode?: ColorSchemeProviderColorMode | null | false;
+    sidebarResizer?: boolean;
+}
+/** Factory dependencies injected by the host stub. */
+export interface HeadWithDefaultsDeps {
+    settings: HeadWithDefaultsSettings;
+    composeMetaTitle: (title: string) => string;
+    withBase: (path: string) => string;
+    absoluteUrl: (pageUrl: string) => string | undefined;
+    generateCssCustomProperties: () => string;
+    generateLightDarkCssProperties: () => string;
+}
+/**
+ * Create a `HeadWithDefaults` component bound to the host's settings and
+ * URL helpers.
+ *
+ * The host stub calls this once with its concrete dependencies and re-exports
+ * the result, mirroring the shape of `createComposeMetaTitle` (S1b) and
+ * `createBuildFrontmatterPreviewEntries`.
+ */
+export declare function createHeadWithDefaults(deps: HeadWithDefaultsDeps): (props: HeadWithDefaultsProps) => JSX.Element;

package/dist/head-with-defaults/index.js

@@ -0,0 +1,62 @@
+import { Fragment, jsx, jsxs } from "preact/jsx-runtime";
+import { OgTags, TwitterCard } from "../head/index.js";
+import { SIDEBAR_RESIZER_RESTORE_SCRIPT } from "../sidebar-resizer/index.js";
+import ColorSchemeProvider from "../theme/color-scheme-provider.js";
+function createHeadWithDefaults(deps) {
+  const {
+    settings,
+    composeMetaTitle,
+    withBase,
+    absoluteUrl,
+    generateCssCustomProperties,
+    generateLightDarkCssProperties
+  } = deps;
+  function HeadWithDefaults({
+    title,
+    description,
+    canonical
+  }) {
+    const { metaTags } = settings;
+    const ogImageUrl = metaTags.ogImage != null && metaTags.ogImage !== false ? absoluteUrl(withBase(metaTags.ogImage)) : void 0;
+    const colorMode = settings.colorMode ? settings.colorMode : null;
+    const cssText = colorMode ? generateLightDarkCssProperties() : generateCssCustomProperties();
+    return /* @__PURE__ */ jsxs(Fragment, { children: [
+      /* @__PURE__ */ jsx(
+        OgTags,
+        {
+          title: composeMetaTitle(title),
+          description: metaTags.description ? description : void 0,
+          ogType: "website",
+          ogUrl: canonical,
+          ogImage: ogImageUrl,
+          ogSiteName: metaTags.ogSiteName ? settings.siteName : void 0
+        }
+      ),
+      metaTags.keywords !== false && metaTags.keywords && metaTags.keywords.length > 0 && /* @__PURE__ */ jsx("meta", { name: "keywords", content: metaTags.keywords }),
+      ogImageUrl !== void 0 && /* @__PURE__ */ jsxs(Fragment, { children: [
+        /* @__PURE__ */ jsx("meta", { property: "og:image:width", content: "1200" }),
+        /* @__PURE__ */ jsx("meta", { property: "og:image:height", content: "630" }),
+        /* @__PURE__ */ jsx("meta", { property: "og:image:alt", content: composeMetaTitle(title) })
+      ] }),
+      metaTags.twitterCard !== false && metaTags.twitterCard !== void 0 && /* @__PURE__ */ jsx(
+        TwitterCard,
+        {
+          card: metaTags.twitterCard,
+          image: ogImageUrl,
+          site: metaTags.twitterSite,
+          creator: metaTags.twitterCreator
+        }
+      ),
+      /* @__PURE__ */ jsx(ColorSchemeProvider, { cssText, colorMode }),
+      settings.sidebarResizer && /* @__PURE__ */ jsx("script", { dangerouslySetInnerHTML: { __html: SIDEBAR_RESIZER_RESTORE_SCRIPT } }),
+      /* @__PURE__ */ jsx("link", { rel: "icon", href: withBase("/favicon.ico"), sizes: "any" }),
+      /* @__PURE__ */ jsx("link", { rel: "icon", type: "image/png", sizes: "32x32", href: withBase("/favicon-32x32.png") }),
+      /* @__PURE__ */ jsx("link", { rel: "icon", type: "image/png", sizes: "16x16", href: withBase("/favicon-16x16.png") }),
+      canonical !== void 0 && /* @__PURE__ */ jsx("link", { rel: "canonical", href: canonical })
+    ] });
+  }
+  return HeadWithDefaults;
+}
+export {
+  createHeadWithDefaults
+};

package/dist/header/header.d.ts

@@ -1,15 +1,13 @@
-import { ComponentChildren, JSX } from 'preact';
-import { Locale, HeaderNavItem, HeaderRightItem } from './types.js';
-
 /** @jsxRuntime automatic */
 /** @jsxImportSource preact */
-
+import type { ComponentChildren, JSX } from "preact";
+import type { HeaderNavItem, HeaderRightItem, Locale } from "./types.js";
 /**
  * Boundary helpers the host injects into `<Header>`. These are the URL
  * builders the legacy header.tsx used to import from `@/utils/base` —
  * pulled into a single prop bag so the v2 package is host-agnostic.
  */
-interface HeaderUrlHelpers {
+export interface HeaderUrlHelpers {
     withBase(path: string): string;
     stripBase(path: string): string;
     navHref(path: string, lang?: Locale, currentVersion?: string): string;
@@ -19,7 +17,7 @@ interface HeaderUrlHelpers {
  * `<Header>`. Matches the surface the legacy header.tsx used from
  * `@/config/i18n`.
  */
-interface HeaderI18n {
+export interface HeaderI18n {
     defaultLocale: string;
     locales: readonly string[];
     t(key: string, lang?: string): string;
@@ -29,7 +27,7 @@ interface HeaderI18n {
  * `Props` interface plus a small set of slot props that replace child
  * Astro components and named `<slot>` outlets.
  */
-interface HeaderProps {
+export interface HeaderProps {
     /** Active locale; `undefined` matches the legacy "no-lang" code path. */
     lang?: Locale;
     /** Current page URL path (as the layout passes from `Astro.url.pathname`). */
@@ -162,6 +160,4 @@ interface HeaderProps {
  *      re-runs after View Transitions (via `AFTER_NAVIGATE_EVENT` from
  *      `../transitions/page-events`).
  */
-declare function Header(props: HeaderProps): JSX.Element;
-
-export { Header, type HeaderI18n, type HeaderProps, type HeaderUrlHelpers };
+export declare function Header(props: HeaderProps): JSX.Element;

package/dist/header/index.d.ts

@@ -1,6 +1,16 @@
-export { HeaderNavChildItem, HeaderNavItem, HeaderRightComponentItem, HeaderRightComponentName, HeaderRightHtmlItem, HeaderRightItem, HeaderRightLinkItem, HeaderRightTriggerItem, HeaderRightTriggerName, Locale } from './types.js';
-export { HeaderRightItemFlags, filterHeaderRightItems } from './right-items.js';
-export { Header, HeaderProps } from './header.js';
-export { NavItemLike, computeActiveNavPath, isNavItemActive, pathForMatch } from './nav-active.js';
-export { NAV_OVERFLOW_SCRIPT } from './nav-overflow-script.js';
-import 'preact';
+/**
+ * Public entry for the JSX `<Header />` port.
+ *
+ * Consumers import from `@takazudo/zudo-doc/header`:
+ *
+ *   import { Header } from "@takazudo/zudo-doc/header";
+ *
+ * The pure helpers used to compute active-link state are also exposed
+ * so downstream tests / custom layouts can reuse them without rebuilding
+ * the `pathForMatch` / `computeActiveNavPath` regex logic.
+ */
+export type { Locale, HeaderNavChildItem, HeaderNavItem, HeaderRightComponentItem, HeaderRightComponentName, HeaderRightHtmlItem, HeaderRightItem, HeaderRightLinkItem, HeaderRightTriggerItem, HeaderRightTriggerName, } from "./types.js";
+export { filterHeaderRightItems, type HeaderRightItemFlags, } from "./right-items.js";
+export { Header, type HeaderProps } from "./header.js";
+export { computeActiveNavPath, isNavItemActive, pathForMatch, type NavItemLike, } from "./nav-active.js";
+export { NAV_OVERFLOW_SCRIPT } from "./nav-overflow-script.js";