@takazudo/zudo-doc 0.2.21 → 0.2.22

package/dist/doc-history-area/index.js

@@ -0,0 +1,76 @@
+import { jsx, jsxs } from "preact/jsx-runtime";
+import { Island } from "@takazudo/zfb";
+import { BodyFootUtilArea } from "../body-foot-util/index.js";
+function createDocHistoryArea(deps) {
+  const {
+    settings,
+    defaultLocale,
+    docHistoryMeta,
+    t,
+    toHistorySlug,
+    buildGitHubSourceUrl,
+    DocHistory
+  } = deps;
+  DocHistory.displayName = "DocHistory";
+  function DocHistoryArea({
+    slug,
+    locale,
+    entrySlug,
+    contentDir,
+    isFallback
+  }) {
+    if (!settings.docHistory) return null;
+    const historySlug = toHistorySlug(slug);
+    const effectiveHistoryLocale = isFallback ? defaultLocale : locale;
+    const composedSlug = effectiveHistoryLocale === defaultLocale ? historySlug : `${effectiveHistoryLocale}/${historySlug}`;
+    const meta = docHistoryMeta[composedSlug];
+    const createdLabel = t("doc.created", locale);
+    const updatedLabel = t("doc.updated", locale);
+    const historyLabel = t("doc.history", locale);
+    const docHistoryLocale = effectiveHistoryLocale === defaultLocale ? void 0 : effectiveHistoryLocale;
+    const docHistoryBasePath = settings.base ?? "/";
+    const author = meta?.author;
+    const createdDate = meta?.createdDate;
+    const updatedDate = meta?.updatedDate;
+    const fallback = /* @__PURE__ */ jsxs("div", { class: "sr-only", children: [
+      author && /* @__PURE__ */ jsx("span", { children: author }),
+      /* @__PURE__ */ jsxs("span", { children: [
+        createdLabel,
+        createdDate ? `: ${createdDate}` : ""
+      ] }),
+      /* @__PURE__ */ jsxs("span", { children: [
+        updatedLabel,
+        updatedDate ? `: ${updatedDate}` : ""
+      ] })
+    ] });
+    const docHistoryIsland = Island({
+      when: "idle",
+      ssrFallback: fallback,
+      children: /* @__PURE__ */ jsx(
+        DocHistory,
+        {
+          slug: historySlug,
+          locale: docHistoryLocale,
+          basePath: docHistoryBasePath
+        }
+      )
+    });
+    const utilSettings = settings.bodyFootUtilArea;
+    const sourceExt = meta?.ext ?? ".mdx";
+    const sourceUrl = utilSettings && utilSettings.viewSourceLink && entrySlug && contentDir ? buildGitHubSourceUrl(contentDir, entrySlug + sourceExt) : null;
+    const viewSourceLabel = t("doc.viewSource", locale);
+    void historyLabel;
+    return /* @__PURE__ */ jsx(
+      BodyFootUtilArea,
+      {
+        docHistoryIsland,
+        sourceUrl,
+        viewSourceLabel
+      }
+    );
+  }
+  return DocHistoryArea;
+}
+export {
+  createDocHistoryArea
+};

package/dist/doc-metainfo-area/index.d.ts

@@ -0,0 +1,46 @@
+/** @jsxRuntime automatic */
+/** @jsxImportSource preact */
+import type { VNode } from "preact";
+/** Per-entry metadata shape from the doc-history manifest. */
+export interface DocHistoryMetaEntry {
+    author: string;
+    createdDate: string;
+    updatedDate: string;
+}
+/** Settings subset read by the DocMetainfoArea factory. */
+export interface DocMetainfoAreaSettings {
+    docMetainfo: boolean;
+}
+/** Dependencies injected by the host stub. */
+export interface DocMetainfoAreaDeps {
+    settings: DocMetainfoAreaSettings;
+    /** Default locale code (e.g. "en"). */
+    defaultLocale: string;
+    /** The parsed `#doc-history-meta` JSON manifest (host-side import). */
+    docHistoryMeta: Record<string, DocHistoryMetaEntry>;
+    /** Translate a UI string key for a locale. */
+    t: (key: string, locale: string) => string;
+    /** Convert a canonical route slug to a history slug (sentinel: "" → "index"). */
+    toHistorySlug: (slug: string) => string;
+}
+export interface DocMetainfoAreaProps {
+    /** Page slug, e.g. "getting-started/intro". */
+    slug: string;
+    /** Active locale string, e.g. "en", "ja". */
+    locale: string;
+    /**
+     * True when this locale page falls back to the base EN collection
+     * (i.e. the slug has no translation for the active locale). When true,
+     * the manifest lookup uses defaultLocale so the visible block resolves
+     * the bare-slug key — the only key that exists for EN-origin files —
+     * matching the dropdown's `effectiveHistoryLocale` derivation in
+     * _doc-history-area.tsx. Display formatting (dates + labels) still uses
+     * the active locale so JA users see JA formatting on fallback pages.
+     */
+    isFallback?: boolean;
+}
+/**
+ * Create a `DocMetainfoArea` component bound to the host's settings and
+ * injected dependencies.
+ */
+export declare function createDocMetainfoArea(deps: DocMetainfoAreaDeps): (props: DocMetainfoAreaProps) => VNode | null;

package/dist/doc-metainfo-area/index.js

@@ -0,0 +1,41 @@
+import { jsx } from "preact/jsx-runtime";
+import { DocMetainfo } from "../metainfo/index.js";
+const LOCALE_TO_BCP47 = {
+  en: "en-US",
+  ja: "ja-JP",
+  de: "de-DE"
+};
+function formatDate(isoDate, locale) {
+  const d = new Date(isoDate);
+  if (isNaN(d.getTime())) return isoDate;
+  return d.toLocaleDateString(LOCALE_TO_BCP47[locale] ?? "en-US", {
+    year: "numeric",
+    month: "short",
+    day: "numeric"
+  });
+}
+function createDocMetainfoArea(deps) {
+  const { settings, defaultLocale, docHistoryMeta, t, toHistorySlug } = deps;
+  function DocMetainfoArea({ slug, locale, isFallback }) {
+    if (!settings.docMetainfo) return null;
+    const historySlug = toHistorySlug(slug);
+    const effectiveHistoryLocale = isFallback ? defaultLocale : locale;
+    const composedSlug = effectiveHistoryLocale === defaultLocale ? historySlug : `${effectiveHistoryLocale}/${historySlug}`;
+    const meta = docHistoryMeta[composedSlug];
+    if (!meta) return null;
+    return /* @__PURE__ */ jsx(
+      DocMetainfo,
+      {
+        createdAt: meta.createdDate ? formatDate(meta.createdDate, locale) : null,
+        updatedAt: meta.updatedDate ? formatDate(meta.updatedDate, locale) : null,
+        author: meta.author || null,
+        createdLabel: t("doc.created", locale),
+        updatedLabel: t("doc.updated", locale)
+      }
+    );
+  }
+  return DocMetainfoArea;
+}
+export {
+  createDocMetainfoArea
+};

package/dist/doc-page-props/index.d.ts

@@ -0,0 +1,93 @@
+export type { HeadingItem } from "../extract-headings/index.js";
+import type { HeadingItem } from "../extract-headings/index.js";
+import type { BreadcrumbItem } from "../breadcrumb/types.js";
+/**
+ * Nav tree node shape as consumed by doc-route pages.
+ *
+ * Structurally identical to the host project's `NavNode` from
+ * `src/utils/docs.ts`. Defined here so the package types do not import
+ * the host `@/` alias. The host's `NavNode` is a structural subtype and
+ * assignable wherever `DocNavNode` is expected.
+ */
+export interface DocNavNode {
+    slug: string;
+    label: string;
+    description?: string;
+    position: number;
+    href?: string;
+    hasPage: boolean;
+    children: DocNavNode[];
+    sortOrder?: "asc" | "desc";
+    collapsed?: boolean;
+}
+/**
+ * Minimal docs frontmatter shape consumed by the doc-page types.
+ *
+ * A structural subset of the host's `DocsData` — only the fields that
+ * `DocPageEntry` and `DocPageBaseProps` actually read. The full `DocsData`
+ * (from `src/config/docs-schema.ts`) is a structural supertype and is
+ * assignable here.
+ */
+export interface DocPageFrontmatter {
+    title: string;
+    description?: string;
+    slug?: string;
+    draft?: boolean;
+    unlisted?: boolean;
+    standalone?: boolean;
+    category_no_page?: boolean;
+    pagination_prev?: string | null;
+    pagination_next?: string | null;
+    tags?: string[];
+    [key: string]: unknown;
+}
+/**
+ * A zfb content collection entry augmented with the `id`/`collection` fields
+ * the host's `@/utils/docs` helpers expect, plus the typed `data` and
+ * renderer surface.
+ *
+ * Structural counterpart of the host's `DocPageEntry` (from
+ * `pages/lib/doc-page-props.ts`). The host stub re-exports this type under
+ * the original name.
+ */
+export interface DocPageEntry {
+    /** zfb content engine slug (filename without `.md`/`.mdx`). */
+    slug: string;
+    /** Bridged from `slug` for host `@/utils/docs` compat. */
+    id: string;
+    /** Collection name, e.g. "docs", "docs-ja", "docs-v-1.0". */
+    collection: string;
+    /** Parsed frontmatter. Structural superset of `DocPageFrontmatter`. */
+    data: DocPageFrontmatter;
+    /** Raw MDX body (for heading extraction). */
+    body?: string;
+    /** zfb module specifier (for Content bridge). */
+    module_specifier: string;
+    /** zfb content renderer — callable Preact component. */
+    Content: unknown;
+}
+export interface AutoIndexNode extends DocNavNode {
+    children: DocNavNode[];
+}
+/** Shared fields present in every doc-page route. */
+interface DocPagePropsBase {
+    breadcrumbs: BreadcrumbItem[];
+    prev: DocNavNode | null;
+    next: DocNavNode | null;
+    /** Depth-2/3/4 headings extracted from the MDX body, for SSG TOC links. */
+    headings: HeadingItem[];
+}
+/** Branch: a real content entry. `autoIndex` is absent. */
+export interface DocPageEntryProps extends DocPagePropsBase {
+    kind: "entry";
+    entry: DocPageEntry;
+    autoIndex?: undefined;
+}
+/** Branch: an auto-generated category index. `entry` is absent. */
+export interface DocPageAutoIndexProps extends DocPagePropsBase {
+    kind: "autoIndex";
+    autoIndex: AutoIndexNode;
+    entry?: undefined;
+}
+/** Discriminated union for the `kind` prop. Narrow via `props.kind === "entry"`. */
+export type DocPageBaseProps = DocPageEntryProps | DocPageAutoIndexProps;

package/dist/doc-page-renderer/index.d.ts

@@ -0,0 +1,128 @@
+/** @jsxRuntime automatic */
+/** @jsxImportSource preact */
+import type { JSX, VNode } from "preact";
+import type { DocPageBaseProps, DocNavNode, DocPageEntry } from "../doc-page-props/index.js";
+import type { VersionBannerLabels } from "../i18n-version/index.js";
+export type { DocPageBaseProps };
+/**
+ * Version config shape — structural subset of the host's `VersionConfig`.
+ * Defined here so the package does not import the host `@/` alias.
+ */
+export interface RenderDocPageVersionConfig {
+    /** Version slug, e.g. "1.0". */
+    slug: string;
+    /** Banner type drives the VersionBanner element (`false` = no banner). */
+    banner?: "unmaintained" | "unreleased" | false;
+}
+export interface RenderDocPageOptions {
+    /** Active locale — drives nav wrappers, labels, and URL building. */
+    locale: string;
+    /** Version config when rendering a versioned route; undefined = latest. */
+    version?: RenderDocPageVersionConfig;
+    /** True when this page falls back to the base EN collection (locale
+     *  routes). Drives the fallback notice + history-area hint. */
+    isFallback?: boolean;
+    /**
+     * Content directory for the doc-history view-source link (e.g. the active
+     * locale's dir, or the base docsDir for EN/fallback pages). Latest routes
+     * pass it; versioned routes omit it — doc history is hidden on versioned
+     * pages regardless (#1916 #5).
+     */
+    docHistoryContentDir?: string;
+}
+/** Dependencies injected by the host stub. */
+export interface DocPageRendererDeps {
+    /** Build a docs URL: `docsUrl(slug, lang?)` → base-prefixed path. */
+    docsUrl: (slug: string, lang?: string) => string;
+    /** Build a versioned docs URL: `versionedDocsUrl(slug, versionSlug, lang?)`. */
+    versionedDocsUrl: (slug: string, versionSlug: string, lang?: string) => string;
+    /** Build an absolute URL: `absoluteUrl(path)` → siteUrl-prefixed. */
+    absoluteUrl: (path: string) => string | undefined;
+    /** Determine the nav section (categoryMatch) for a slug. */
+    getNavSectionForSlug: (slug: string) => string | undefined;
+    /** Convert a content entry slug to a canonical route slug. */
+    toRouteSlug: (id: string) => string;
+    /**
+     * Build locale-aware MDX components bag.
+     * Host passes `createMdxComponents` (from `pages/_mdx-components.ts`).
+     */
+    createMdxComponents: (locale: string) => Record<string, unknown>;
+    /** Translate a UI string key for a locale. */
+    t: (key: string, locale: string) => string;
+    /**
+     * Build an inline version switcher VNode for the breadcrumb rightSlot.
+     * Host passes `buildInlineVersionSwitcher` from `pages/lib/_inline-version-switcher.tsx`.
+     */
+    buildInlineVersionSwitcher: (slug: string, locale: string, currentVersion?: string) => JSX.Element | undefined;
+    /**
+     * The `DocPageShell` component (host-side factory result from
+     * `@takazudo/zudo-doc/doc-page-shell`).
+     */
+    DocPageShell: (props: {
+        kind: "entry" | "autoIndex";
+        locale: string;
+        slug: string;
+        title: string;
+        description?: string;
+        canonical?: string;
+        breadcrumbs: Array<{
+            label: string;
+            href?: string;
+        }>;
+        prev: DocNavNode | null;
+        next: DocNavNode | null;
+        headings: Array<{
+            depth: number;
+            slug: string;
+            text: string;
+        }>;
+        navSection: string | undefined;
+        sidebarPersistKey: string | undefined;
+        hideSidebar?: boolean;
+        hideToc?: boolean;
+        currentPath: string;
+        currentVersion?: string;
+        versionSwitcher: JSX.Element | undefined;
+        versionBanner?: "unmaintained" | "unreleased";
+        versionBannerLatestUrl?: string;
+        versionBannerLabels?: VersionBannerLabels;
+        autoIndexLabel?: string;
+        autoIndexChildren?: DocNavNode[];
+        metainfoSlot?: VNode | null;
+        contentHeaderSlot?: VNode;
+        contentSlot?: VNode;
+        docHistorySlot?: VNode | null;
+    }) => JSX.Element;
+    /**
+     * The `DocContentHeader` component (host-side factory result).
+     */
+    DocContentHeader: (props: {
+        entry: DocPageEntry;
+        slug: string;
+        locale: string;
+        isFallback?: boolean;
+        version?: string;
+    }) => JSX.Element;
+    /**
+     * The `DocMetainfoArea` component (host-side factory result).
+     */
+    DocMetainfoArea: (props: {
+        slug: string;
+        locale: string;
+        isFallback?: boolean;
+    }) => JSX.Element | null;
+    /**
+     * The `DocHistoryArea` component (host-side factory result).
+     */
+    DocHistoryArea: (props: {
+        slug: string;
+        locale: string;
+        entrySlug?: string;
+        contentDir?: string;
+        isFallback?: boolean;
+    }) => VNode | null;
+}
+/**
+ * Create a `renderDocPage` function bound to the host's injected dependencies.
+ */
+export declare function createRenderDocPage(deps: DocPageRendererDeps): (props: DocPageBaseProps, opts: RenderDocPageOptions) => JSX.Element;

package/dist/doc-page-renderer/index.js

@@ -0,0 +1,103 @@
+import { jsx } from "preact/jsx-runtime";
+function createRenderDocPage(deps) {
+  const {
+    docsUrl,
+    versionedDocsUrl,
+    absoluteUrl,
+    getNavSectionForSlug,
+    toRouteSlug,
+    createMdxComponents,
+    t,
+    buildInlineVersionSwitcher,
+    DocPageShell,
+    DocContentHeader,
+    DocMetainfoArea,
+    DocHistoryArea
+  } = deps;
+  function renderDocPage(props, opts) {
+    const { breadcrumbs, prev, next, headings } = props;
+    const { locale, version, isFallback } = opts;
+    const slug = props.kind === "autoIndex" ? props.autoIndex.slug : props.entry.data.slug ?? toRouteSlug(props.entry.slug);
+    const title = props.kind === "autoIndex" ? props.autoIndex.label : props.entry.data.title;
+    const description = props.kind === "autoIndex" ? props.autoIndex.description : props.entry.data.description;
+    const components = createMdxComponents(locale);
+    const autoIndexChildren = props.kind === "autoIndex" ? version ? props.autoIndex.children.filter((c) => c.hasPage || c.children.length > 0) : props.autoIndex.children.filter((c) => c.hasPage || c.children.length > 0).map((c) => ({
+      ...c,
+      href: c.href ?? docsUrl(c.slug, locale)
+    })) : [];
+    const versionBannerType = version?.banner ? version.banner : void 0;
+    const versionBannerLatestUrl = versionBannerType ? docsUrl(slug, locale) : void 0;
+    const versionBannerLabels = versionBannerType ? {
+      message: versionBannerType === "unmaintained" ? t("version.banner.unmaintained", locale) : t("version.banner.unreleased", locale),
+      latestLink: t("version.banner.latestLink", locale)
+    } : void 0;
+    const currentPath = version ? versionedDocsUrl(slug, version.slug, locale) : docsUrl(slug, locale);
+    const canonical = absoluteUrl(currentPath);
+    const navSection = getNavSectionForSlug(slug);
+    const hideSidebar = props.kind === "entry" ? props.entry.data.hide_sidebar : void 0;
+    const sidebarPersistKey = hideSidebar ? void 0 : `sidebar-${locale}-${navSection ?? "default"}`;
+    const ContentComponent = props.kind === "entry" ? props.entry.Content : null;
+    return /* @__PURE__ */ jsx(
+      DocPageShell,
+      {
+        kind: props.kind,
+        locale,
+        slug,
+        title,
+        description,
+        canonical,
+        breadcrumbs,
+        prev,
+        next,
+        headings,
+        navSection,
+        sidebarPersistKey,
+        hideSidebar,
+        hideToc: props.kind === "entry" ? props.entry.data.hide_toc : void 0,
+        currentPath,
+        currentVersion: version?.slug,
+        versionSwitcher: buildInlineVersionSwitcher(slug, locale, version?.slug),
+        versionBanner: versionBannerType,
+        versionBannerLatestUrl,
+        versionBannerLabels,
+        autoIndexLabel: props.kind === "autoIndex" ? props.autoIndex.label : void 0,
+        autoIndexChildren,
+        metainfoSlot: (
+          // Versioned gate mirrors DocContentHeader: the doc-history-meta
+          // manifest is built from latest dirs only, so a bare versioned slug
+          // would surface the LATEST page's Created/Updated/Author.
+          !version && props.kind === "autoIndex" ? /* @__PURE__ */ jsx(DocMetainfoArea, { slug, locale, isFallback }) : null
+        ),
+        contentHeaderSlot: props.kind === "entry" ? /* @__PURE__ */ jsx(
+          DocContentHeader,
+          {
+            entry: props.entry,
+            slug,
+            locale,
+            isFallback,
+            version: version?.slug
+          }
+        ) : void 0,
+        contentSlot: ContentComponent ? /* @__PURE__ */ jsx(ContentComponent, { components }) : void 0,
+        docHistorySlot: (
+          // #1916 #5: doc-history hidden on versioned pages until versioned
+          // history is supported.
+          !version && opts.docHistoryContentDir !== void 0 && props.kind === "entry" && !props.entry.data.unlisted ? /* @__PURE__ */ jsx(
+            DocHistoryArea,
+            {
+              slug,
+              locale,
+              entrySlug: props.entry.slug,
+              contentDir: opts.docHistoryContentDir,
+              isFallback
+            }
+          ) : null
+        )
+      }
+    );
+  }
+  return renderDocPage;
+}
+export {
+  createRenderDocPage
+};

package/dist/doc-page-shell/index.d.ts

@@ -0,0 +1,136 @@
+/** @jsxRuntime automatic */
+/** @jsxImportSource preact */
+import type { ComponentChildren, JSX, VNode } from "preact";
+import type { VersionBannerLabels } from "../i18n-version/index.js";
+/** A heading item for the TOC. */
+export interface DocPageHeading {
+    depth: number;
+    slug: string;
+    text: string;
+}
+/** A breadcrumb item. */
+export interface DocPageBreadcrumbItem {
+    label: string;
+    href?: string;
+}
+/** A nav node for prev/next/autoIndex. */
+export interface DocPageNavNode {
+    slug: string;
+    label: string;
+    href?: string;
+    hasPage: boolean;
+    children: DocPageNavNode[];
+}
+/** Slots and parameters that vary between the 4 doc routes. */
+export interface DocPageShellProps {
+    /** Discriminates the body: a real entry vs an auto-generated category index. */
+    kind: "entry" | "autoIndex";
+    /** Active locale string, e.g. "en", "ja". */
+    locale: string;
+    /** Canonical route slug for this page (no version/locale prefix). */
+    slug: string;
+    /** Page title (entry title or auto-index label). */
+    title: string;
+    /** Page description (may be undefined). */
+    description?: string;
+    /** Absolute canonical URL, or undefined when siteUrl is unset. */
+    canonical?: string;
+    /** Pre-resolved breadcrumb trail (hrefs already remapped per route). */
+    breadcrumbs: DocPageBreadcrumbItem[];
+    /** Pre-resolved prev/next nav nodes (hrefs already remapped per route). */
+    prev: DocPageNavNode | null;
+    next: DocPageNavNode | null;
+    /** Depth-2/3/4 headings for the SSG TOC. */
+    headings: DocPageHeading[];
+    /** Sidebar/header nav-section key for this slug. */
+    navSection: string | undefined;
+    /** Per-page sidebar persist key (undefined when the sidebar is hidden). */
+    sidebarPersistKey: string | undefined;
+    /** Whether to hide the sidebar entirely (entry frontmatter). */
+    hideSidebar?: boolean;
+    /** Whether to hide the TOC (entry frontmatter). */
+    hideToc?: boolean;
+    /** Path of THIS page used by Header/Sidebar to mark the active item. */
+    currentPath: string;
+    /** Version slug for Header/Sidebar active-state, or undefined on latest routes. */
+    currentVersion?: string;
+    /** Inline version switcher VNode for the breadcrumb right-slot. */
+    versionSwitcher: ComponentChildren;
+    /** Version banner type ("unmaintained" | "unreleased") or undefined on latest. */
+    versionBanner?: "unmaintained" | "unreleased";
+    /** URL of the latest equivalent page for the version banner link. */
+    versionBannerLatestUrl?: string;
+    /** Localized version-banner labels. */
+    versionBannerLabels?: VersionBannerLabels;
+    /** Auto-index branch: label heading text. */
+    autoIndexLabel?: string;
+    /** Auto-index branch: pre-filtered + href-remapped child cards. */
+    autoIndexChildren?: DocPageNavNode[];
+    /**
+     * Auto-index branch slot: the build-time date block (DocMetainfoArea), or
+     * null to omit it.
+     */
+    metainfoSlot?: VNode | null;
+    /**
+     * Entry branch slot: the content header (h1 + meta + tags + description +
+     * frontmatter preview), built per route (carries isFallback).
+     */
+    contentHeaderSlot?: VNode;
+    /** Entry branch slot: the rendered MDX `<Content />`. */
+    contentSlot?: VNode;
+    /**
+     * Entry branch slot: the document-utilities area (DocHistoryArea), or null
+     * to omit it.
+     */
+    docHistorySlot?: VNode | null;
+}
+/** Settings subset read by {@link createDocPageShell}. */
+export interface DocPageShellSettings {
+    metaTags: {
+        description?: boolean | null;
+    };
+    noindex?: boolean;
+    dynamicPageTransition?: boolean;
+}
+/** Dependencies injected by the host stub. */
+export interface DocPageShellDeps {
+    settings: DocPageShellSettings;
+    composeMetaTitle: (title: string) => string;
+    getTocTitle: (locale: string) => string;
+    HeadWithDefaults: (props: {
+        title: string;
+        description?: string;
+        canonical?: string;
+    }) => JSX.Element;
+    SidebarWithDefaults: (props: {
+        currentSlug?: string;
+        lang?: string;
+        navSection?: string;
+        currentVersion?: string;
+        currentPath?: string;
+    }) => JSX.Element;
+    HeaderWithDefaults: (props: {
+        lang?: string;
+        currentSlug?: string;
+        navSection?: string;
+        currentVersion?: string;
+        currentPath?: string;
+    }) => JSX.Element;
+    FooterWithDefaults: (props: {
+        lang?: string;
+    }) => JSX.Element;
+    SidebarPrepaint: (props: {
+        hideSidebar?: boolean;
+    }) => JSX.Element | undefined;
+    DocBodyEnd: (props: Record<string, never>) => JSX.Element;
+    DocPager: (props: {
+        prev: DocPageNavNode | null;
+        next: DocPageNavNode | null;
+        locale: string;
+    }) => JSX.Element;
+}
+/**
+ * Create a `DocPageShell` component bound to the host's settings and
+ * component dependencies.
+ */
+export declare function createDocPageShell(deps: DocPageShellDeps): (props: DocPageShellProps) => JSX.Element;