@mintlify/astro 0.1.4 → 0.1.5

package/dist/helpers.d.ts

@@ -0,0 +1,98 @@
+import { type NavigationConfig, type DocsConfig } from '@mintlify/validation';
+export interface NavPage {
+    href: string;
+    title: string;
+    icon?: string;
+    tag?: string;
+    api?: string;
+    deprecated?: boolean;
+}
+export interface NavGroup {
+    group: string;
+    pages: NavEntry[];
+    icon?: string;
+    tag?: string;
+}
+export type NavEntry = NavPage | NavGroup;
+export type NavNode = Record<string, unknown>;
+export interface TabInfo {
+    name: string;
+    href: string;
+    isActive: boolean;
+}
+export type Favicons = {
+    icons: Array<{
+        rel?: string;
+        type?: string;
+        sizes?: string;
+        href?: string;
+        media?: string;
+    }>;
+};
+export type AnchorItem = {
+    name: string;
+    href: string;
+    icon?: string;
+    color?: string;
+};
+export declare function isNavPage(entry: NavEntry): entry is NavPage;
+export declare function isNavGroup(entry: NavEntry): entry is NavGroup;
+/**
+ * Decorates a raw `NavigationConfig` from docs.json by resolving string page
+ * slugs into `{ href, title }` entries using the provided title map.
+ */
+export declare function decorateNavigation(nav: NavigationConfig, titleMap: Record<string, string>): NavNode;
+/**
+ * Extracts the sidebar navigation entries for the current page's division.
+ */
+export declare function unwrapNav(nav: NavNode, currentPath: string): NavEntry[];
+/**
+ * Returns true if the given path is contained within the navigation entries.
+ */
+export declare function containsPath(entries: NavEntry[], path: string): boolean;
+/**
+ * Builds tab metadata from the top-level `tabs` division of the navigation.
+ */
+export declare function getTabsFromNav(nav: NavNode, currentPath: string): TabInfo[] | null;
+/**
+ * Returns the previous and next pages relative to the current path,
+ * for footer navigation.
+ */
+export declare function getFooterPages(entries: NavEntry[], currentPath: string): {
+    prev: NavPage | null;
+    next: NavPage | null;
+};
+/**
+ * Finds the group label that contains the given path.
+ */
+export declare function findGroupForPath(entries: NavEntry[], path: string): string | undefined;
+/**
+ * Resolves the favicon configuration from docs.json into link element data.
+ * Handles both string and `{ light, dark }` formats.
+ */
+export declare function getFavicons(config: DocsConfig): Favicons | undefined;
+/**
+ * Extracts anchor items from `navigation.global.anchors` in docs.json.
+ */
+export declare function getAnchors(config: DocsConfig): AnchorItem[];
+export interface PageData {
+    favicons: Favicons | undefined;
+    navigation: NavNode;
+    sidebarEntries: NavEntry[];
+    tabs: TabInfo[] | null;
+    footerPages: {
+        prev: NavPage | null;
+        next: NavPage | null;
+    };
+    groupName: string | undefined;
+    anchors: AnchorItem[];
+}
+/**
+ * Resolves the page context from a docs config in a single call.
+ * Orchestrates navigation decoration, sidebar entries, tabs, footer pages,
+ * group name, and anchors.
+ */
+export declare function resolvePageData(config: DocsConfig, options: {
+    currentPath: string;
+    titleMap: Record<string, string>;
+}): PageData;

package/dist/helpers.js

@@ -0,0 +1,219 @@
+import { sep } from 'node:path';
+import { divisions } from '@mintlify/validation';
+export function isNavPage(entry) {
+    return 'href' in entry && 'title' in entry;
+}
+export function isNavGroup(entry) {
+    return 'group' in entry && 'pages' in entry;
+}
+function normalizePath(path) {
+    let normalized = sep !== '/' ? path.replaceAll(sep, '/') : path;
+    if (normalized.length > 1 && normalized.endsWith('/')) {
+        normalized = normalized.slice(0, -1);
+    }
+    return normalized;
+}
+/**
+ * Decorates a raw `NavigationConfig` from docs.json by resolving string page
+ * slugs into `{ href, title }` entries using the provided title map.
+ */
+export function decorateNavigation(nav, titleMap) {
+    return decorateNavNode(nav, titleMap);
+}
+function decorateNavNode(nav, titleMap) {
+    const result = { ...nav };
+    const pages = result.pages;
+    if (Array.isArray(pages) && !result.group) {
+        result.pages = pages.map((p) => decorateEntry(p, titleMap));
+    }
+    const groups = result.groups;
+    if (Array.isArray(groups)) {
+        result.groups = groups.map((g) => decorateEntry(g, titleMap));
+    }
+    for (const key of divisions) {
+        const division = result[key];
+        if (Array.isArray(division)) {
+            result[key] = division.map((item) => decorateNavNode(item, titleMap));
+        }
+    }
+    return result;
+}
+function decorateEntry(entry, titleMap) {
+    if (typeof entry === 'string') {
+        return {
+            href: entry === 'index' ? '/' : `/${entry}`,
+            title: titleMap[entry] ?? slugToTitle(entry),
+        };
+    }
+    if (typeof entry === 'object' && entry !== null) {
+        const node = entry;
+        const pages = node.pages;
+        if (node.group != null && Array.isArray(pages)) {
+            return {
+                ...node,
+                pages: pages.map((page) => decorateEntry(page, titleMap)),
+            };
+        }
+    }
+    return entry;
+}
+function slugToTitle(slug) {
+    const last = slug.split('/').pop() ?? slug;
+    return last
+        .split('-')
+        .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+        .join(' ');
+}
+/**
+ * Extracts the sidebar navigation entries for the current page's division.
+ */
+export function unwrapNav(nav, currentPath) {
+    const groups = nav.groups;
+    if (Array.isArray(groups))
+        return groups;
+    const pages = nav.pages;
+    if (Array.isArray(pages) && !nav.group)
+        return pages;
+    for (const key of divisions) {
+        const divisionArr = nav[key];
+        if (!Array.isArray(divisionArr))
+            continue;
+        for (const division of divisionArr) {
+            const entries = unwrapNav(division, currentPath);
+            if (entries.length > 0 && containsPath(entries, currentPath))
+                return entries;
+        }
+        if (divisionArr.length > 0) {
+            return unwrapNav(divisionArr[0], currentPath);
+        }
+    }
+    return [];
+}
+/**
+ * Returns true if the given path is contained within the navigation entries.
+ */
+export function containsPath(entries, path) {
+    const normalized = normalizePath(path);
+    return entries.some((entry) => isNavPage(entry)
+        ? normalizePath(entry.href) === normalized
+        : isNavGroup(entry) && containsPath(entry.pages, normalized));
+}
+/**
+ * Builds tab metadata from the top-level `tabs` division of the navigation.
+ */
+export function getTabsFromNav(nav, currentPath) {
+    const tabs = nav.tabs;
+    if (!Array.isArray(tabs))
+        return null;
+    return tabs.map((tab) => {
+        const tabNode = tab;
+        const entries = unwrapNav(tabNode, currentPath);
+        return {
+            name: tabNode.tab ?? '',
+            href: findFirstPage(entries)?.href ?? '/',
+            isActive: containsPath(entries, currentPath),
+        };
+    });
+}
+function findFirstPage(entries) {
+    for (const entry of entries) {
+        if (isNavPage(entry))
+            return entry;
+        if (isNavGroup(entry)) {
+            const page = findFirstPage(entry.pages);
+            if (page)
+                return page;
+        }
+    }
+    return undefined;
+}
+/**
+ * Returns the previous and next pages relative to the current path,
+ * for footer navigation.
+ */
+export function getFooterPages(entries, currentPath) {
+    const normalized = normalizePath(currentPath);
+    const pages = flattenPages(entries);
+    const idx = pages.findIndex((p) => normalizePath(p.href) === normalized);
+    return {
+        prev: idx > 0 ? pages[idx - 1] : null,
+        next: idx < pages.length - 1 ? pages[idx + 1] : null,
+    };
+}
+function flattenPages(entries) {
+    return entries.flatMap((x) => isNavGroup(x) ? flattenPages(x.pages) : [x]);
+}
+/**
+ * Finds the group label that contains the given path.
+ */
+export function findGroupForPath(entries, path) {
+    const normalized = normalizePath(path);
+    for (const entry of entries) {
+        if (isNavGroup(entry)) {
+            for (const page of entry.pages) {
+                if (isNavPage(page) && normalizePath(page.href) === normalized) {
+                    return entry.group;
+                }
+                if (isNavGroup(page)) {
+                    const nested = findGroupForPath([page], normalized);
+                    if (nested)
+                        return nested;
+                }
+            }
+        }
+    }
+    return undefined;
+}
+/**
+ * Resolves the favicon configuration from docs.json into link element data.
+ * Handles both string and `{ light, dark }` formats.
+ */
+export function getFavicons(config) {
+    const faviconConfig = config.favicon;
+    const faviconHref = typeof faviconConfig === 'string'
+        ? faviconConfig
+        : (faviconConfig?.light ?? faviconConfig?.dark);
+    if (!faviconHref) {
+        return undefined;
+    }
+    return {
+        icons: [
+            {
+                rel: 'icon',
+                type: 'image/svg+xml',
+                href: faviconHref,
+            },
+        ],
+    };
+}
+/**
+ * Extracts anchor items from `navigation.global.anchors` in docs.json.
+ */
+export function getAnchors(config) {
+    const anchors = config.navigation.global?.anchors ?? [];
+    return anchors.map((anchor) => ({
+        name: anchor.anchor,
+        href: anchor.href,
+        icon: typeof anchor.icon === 'string' ? anchor.icon : anchor.icon?.name,
+        color: anchor.color?.light ?? anchor.color?.dark,
+    }));
+}
+/**
+ * Resolves the page context from a docs config in a single call.
+ * Orchestrates navigation decoration, sidebar entries, tabs, footer pages,
+ * group name, and anchors.
+ */
+export function resolvePageData(config, options) {
+    const { currentPath, titleMap } = options;
+    const decoratedNav = decorateNavigation(config.navigation, titleMap);
+    const sidebarEntries = unwrapNav(decoratedNav, currentPath);
+    return {
+        favicons: getFavicons(config),
+        navigation: decoratedNav,
+        sidebarEntries,
+        tabs: getTabsFromNav(decoratedNav, currentPath),
+        footerPages: getFooterPages(sidebarEntries, currentPath),
+        groupName: findGroupForPath(sidebarEntries, currentPath),
+        anchors: getAnchors(config),
+    };
+}

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 import type { AstroIntegration } from 'astro';
 export type { DocsConfig, NavigationConfig } from './types.js';
+export { readDocsConfig } from './utils/read-docs-config.js';
 export interface MintlifyOptions {
     docsDir?: string;
 }

package/dist/index.js

@@ -11,6 +11,7 @@ import { readDocsConfig } from './utils/read-docs-config.js';
 import { readPageContent } from './utils/read-page-content.js';
 import { createStaticAssetMiddleware } from './utils/serve-docs-assets.js';
 import { writePageContent } from './utils/write-page-content.js';
+export { readDocsConfig } from './utils/read-docs-config.js';
 export function mintlify(options) {
     let docsDir;
     let staticDir;

package/dist/integration.d.ts

@@ -0,0 +1,5 @@
+import type { AstroIntegration } from 'astro';
+export interface MintlifyOptions {
+    docsDir?: string;
+}
+export declare function mintlify(options?: MintlifyOptions): AstroIntegration;

package/dist/integration.js

@@ -0,0 +1,67 @@
+import { cp } from 'node:fs/promises';
+import { join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { getAllPathsInDocsNav } from '@mintlify/common';
+import { clearContentDirectory } from './utils/clear-content-directory.js';
+import { copyAssets } from './utils/copy-assets.js';
+import { findUserComponents } from './utils/find-user-components.js';
+import { loadAllSnippets } from './utils/load-all-snippets.js';
+import { initLogger } from './utils/logger.js';
+import { readDocsConfig } from './utils/read-docs-config.js';
+import { readPageContent } from './utils/read-page-content.js';
+import { createStaticAssetMiddleware } from './utils/serve-docs-assets.js';
+import { writePageContent } from './utils/write-page-content.js';
+export function mintlify(options) {
+    let docsDir;
+    let staticDir;
+    return {
+        name: '@mintlify/astro',
+        hooks: {
+            'astro:config:setup': async ({ config: astroConfig, logger }) => {
+                initLogger(logger);
+                const rootDir = fileURLToPath(astroConfig.root);
+                const contentDir = join(rootDir, '.mintlify', 'docs');
+                const componentsDir = join(rootDir, '.mintlify', 'components');
+                staticDir = join(rootDir, '.mintlify', 'static');
+                docsDir = resolve(rootDir, options?.docsDir ?? './docs');
+                await Promise.all([
+                    clearContentDirectory(contentDir),
+                    clearContentDirectory(componentsDir),
+                    clearContentDirectory(staticDir),
+                ]);
+                const assetCount = await copyAssets(docsDir, staticDir);
+                logger.info(`Copied ${assetCount} static assets`);
+                const snippets = await loadAllSnippets(docsDir);
+                logger.info(`Loaded ${snippets.length} snippet files`);
+                const userComponents = await findUserComponents(docsDir);
+                const docsConfig = await readDocsConfig(docsDir);
+                const pagePaths = getAllPathsInDocsNav(docsConfig.navigation);
+                logger.info(`Found ${pagePaths.length} pages to sync`);
+                await Promise.all(pagePaths.map(async (pagePath) => {
+                    try {
+                        const { content, slug } = await readPageContent(pagePath, docsDir);
+                        await writePageContent({
+                            content,
+                            slug,
+                            contentDir,
+                            componentsDir,
+                            userComponents,
+                            snippets,
+                        });
+                    }
+                    catch (error) {
+                        logger.warn(`Failed to read content for ${pagePath}: ${error}`);
+                    }
+                }));
+                logger.info(`Synced ${pagePaths.length} pages`);
+            },
+            'astro:server:setup': ({ server }) => {
+                server.middlewares.use(createStaticAssetMiddleware(staticDir));
+            },
+            'astro:build:done': async ({ dir }) => {
+                const outputDir = fileURLToPath(dir);
+                await cp(staticDir, outputDir, { recursive: true });
+            },
+        },
+    };
+}

package/dist/mintlify-components.d.ts

@@ -0,0 +1,121 @@
+import type { ReactNode } from 'react';
+import type { MDXComponents } from 'mdx/types';
+export declare const components: {
+    Accordion: (({ title, description, defaultOpen, icon, iconType, children, className, _disabled, trackOpen, trackClose, onMount, topOffset, getInitialOpenFromUrl, onUrlStateChange, _onKeyDownCapture, }: import("@mintlify/components").AccordionProps) => import("react/jsx-runtime").JSX.Element) & {
+        Group: ({ children, className }: import("@mintlify/components").AccordionGroupProps) => import("react/jsx-runtime").JSX.Element;
+    };
+    Badge: ({ children, className, color, shape, variant: variantProp, stroke, disabled, size, leadIcon, tailIcon: tailIconProp, icon, iconType, iconLibrary, onClick, href, }: import("@mintlify/components").BadgeProps) => import("react/jsx-runtime").JSX.Element;
+    Callout: ({ children, variant, icon, iconType, iconLibrary, color, className, ariaLabel, }: import("@mintlify/components").CalloutProps) => import("react/jsx-runtime").JSX.Element;
+    Card: ({ title, icon, iconType, iconLibrary, color, horizontal, href, img, children, disabled, cta, arrow, as, className, }: import("@mintlify/components").CardComponentProps) => import("react/jsx-runtime").JSX.Element;
+    Check: (props: {
+        children: ReactNode;
+        className?: string | undefined;
+        color?: string | undefined;
+        icon?: ReactNode;
+        iconType?: ("brands" | "duotone" | "light" | "regular" | "sharp-duotone-solid" | "sharp-light" | "sharp-regular" | "sharp-solid" | "sharp-thin" | "solid" | "thin") | undefined;
+        iconLibrary?: ("fontawesome" | "lucide") | undefined;
+        ariaLabel?: string | undefined;
+    }) => import("react/jsx-runtime").JSX.Element;
+    CodeBlock: (params: import("@mintlify/components").CodeBlockProps) => import("react/jsx-runtime").JSX.Element;
+    CodeGroup: ({ children, isSmallText, className, noMargins, dropdown, feedbackModalOpen, anchorRef, codeBlockTheme, codeBlockThemeObject, initialSelectedTab, onSelectedTabChange, askAiButton, feedbackButton, copyButtonProps, }: import("@mintlify/components").CodeGroupProps) => import("react/jsx-runtime").JSX.Element | null;
+    Color: {
+        ({ children, variant, className }: import("@mintlify/components").ColorProps): import("react/jsx-runtime").JSX.Element;
+        Row: ({ children, title }: import("@mintlify/components").ColorRowProps) => import("react/jsx-runtime").JSX.Element;
+        Item: ({ name, value }: import("@mintlify/components").ColorItemProps) => import("react/jsx-runtime").JSX.Element;
+    };
+    Columns: ({ children, className, cols }: import("@mintlify/components").ColumnsProps) => import("react/jsx-runtime").JSX.Element;
+    Danger: (props: {
+        children: ReactNode;
+        className?: string | undefined;
+        color?: string | undefined;
+        icon?: ReactNode;
+        iconType?: ("brands" | "duotone" | "light" | "regular" | "sharp-duotone-solid" | "sharp-light" | "sharp-regular" | "sharp-solid" | "sharp-thin" | "solid" | "thin") | undefined;
+        iconLibrary?: ("fontawesome" | "lucide") | undefined;
+        ariaLabel?: string | undefined;
+    }) => import("react/jsx-runtime").JSX.Element;
+    Expandable: ({ title, defaultOpen, onChange: onChangeProp, lazy, className, children, uniqueParamId, onMount, onOpen, onClose, openedText, closedText, hasScrolledToAnchorRef, anchor, }: import("@mintlify/components").ExpandableProps) => import("react/jsx-runtime").JSX.Element;
+    Frame: ({ as: Component, title, description, renderDescription, style, className, children, }: import("@mintlify/components").FrameProps) => import("react/jsx-runtime").JSX.Element;
+    Icon: ({ icon, iconType, color, colorLight, colorDark, size, className, iconLibrary, basePath, pageType, overrideColor, overrideSize, }: import("@mintlify/components").IconProps) => import("react/jsx-runtime").JSX.Element | null;
+    Info: (props: {
+        children: ReactNode;
+        className?: string | undefined;
+        color?: string | undefined;
+        icon?: ReactNode;
+        iconType?: ("brands" | "duotone" | "light" | "regular" | "sharp-duotone-solid" | "sharp-light" | "sharp-regular" | "sharp-solid" | "sharp-thin" | "solid" | "thin") | undefined;
+        iconLibrary?: ("fontawesome" | "lucide") | undefined;
+        ariaLabel?: string | undefined;
+    }) => import("react/jsx-runtime").JSX.Element;
+    Mermaid: ({ chart, className, ariaLabel, placement, actions, }: import("@mintlify/components").MermaidProps) => import("react/jsx-runtime").JSX.Element;
+    Note: (props: {
+        children: ReactNode;
+        className?: string | undefined;
+        color?: string | undefined;
+        icon?: ReactNode;
+        iconType?: ("brands" | "duotone" | "light" | "regular" | "sharp-duotone-solid" | "sharp-light" | "sharp-regular" | "sharp-solid" | "sharp-thin" | "solid" | "thin") | undefined;
+        iconLibrary?: ("fontawesome" | "lucide") | undefined;
+        ariaLabel?: string | undefined;
+    }) => import("react/jsx-runtime").JSX.Element;
+    Panel: ({ children, className, ...props }: import("@mintlify/components").PanelProps) => import("react/jsx-runtime").JSX.Element;
+    Property: ({ name, type, location, hidden, default: defaultValue, required, deprecated, children, id, pre, post, className, onMount, navigateToHeaderAriaLabel, defaultLabel, requiredLabel, deprecatedLabel, }: import("@mintlify/components").PropertyProps) => import("react/jsx-runtime").JSX.Element | null;
+    Steps: {
+        ({ children, titleSize, className }: import("@mintlify/components").StepsProps): import("react/jsx-runtime").JSX.Element;
+        Item: ({ stepNumber, icon, iconType, iconLibrary, title, children, titleSize, className, isLast, id, noAnchor, scrollElementIntoView, onRegisterHeading, onUnregisterHeading, _hasContext, onCopyAnchorLink, }: import("@mintlify/components").StepsItemProps) => import("react/jsx-runtime").JSX.Element;
+    };
+    Tabs: (({ children, defaultTabIndex, onTabChange, className, borderBottom, ariaLabel, panelsRef, }: import("@mintlify/components").TabsProps) => import("react/jsx-runtime").JSX.Element) & {
+        Item: ({ children }: import("@mintlify/components").TabsItemProps) => import("react/jsx-runtime").JSX.Element;
+    };
+    Tile: ({ href, children, title, description, className }: import("@mintlify/components").TileProps) => import("react/jsx-runtime").JSX.Element;
+    Tip: (props: {
+        children: ReactNode;
+        className?: string | undefined;
+        color?: string | undefined;
+        icon?: ReactNode;
+        iconType?: ("brands" | "duotone" | "light" | "regular" | "sharp-duotone-solid" | "sharp-light" | "sharp-regular" | "sharp-solid" | "sharp-thin" | "solid" | "thin") | undefined;
+        iconLibrary?: ("fontawesome" | "lucide") | undefined;
+        ariaLabel?: string | undefined;
+    }) => import("react/jsx-runtime").JSX.Element;
+    Tooltip: ({ description, children, title, cta, href, className, side, align, }: import("@mintlify/components").TooltipProps) => import("react/jsx-runtime").JSX.Element | null;
+    Tree: (({ className, children }: import("@mintlify/components").TreeProps) => import("react/jsx-runtime").JSX.Element) & {
+        File: ({ name }: import("@mintlify/components").TreeFileProps) => import("react/jsx-runtime").JSX.Element;
+        Folder: ({ name, defaultOpen, children, openable: _openable, }: import("@mintlify/components").TreeFolderProps) => import("react/jsx-runtime").JSX.Element;
+    };
+    Update: import("react").ForwardRefExoticComponent<{
+        id: string;
+        label: string;
+        description?: string;
+        tags?: string[];
+        rss?: {
+            title?: string;
+            description?: string;
+        };
+        onRegisterHeading?: (id: string, rect: import("react-use-rect").Rect) => void;
+        onUnregisterHeading?: (id: string) => void;
+        hasContext?: boolean;
+        isVisible: boolean;
+        onCopyAnchorLink?: (id: string) => void;
+    } & Omit<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, keyof {
+        id: string;
+        label: string;
+        description?: string;
+        tags?: string[];
+        rss?: {
+            title?: string;
+            description?: string;
+        };
+        onRegisterHeading?: (id: string, rect: import("react-use-rect").Rect) => void;
+        onUnregisterHeading?: (id: string) => void;
+        hasContext?: boolean;
+        isVisible: boolean;
+        onCopyAnchorLink?: (id: string) => void;
+    }> & import("react").RefAttributes<HTMLDivElement>>;
+    Warning: (props: {
+        children: ReactNode;
+        className?: string | undefined;
+        color?: string | undefined;
+        icon?: ReactNode;
+        iconType?: ("brands" | "duotone" | "light" | "regular" | "sharp-duotone-solid" | "sharp-light" | "sharp-regular" | "sharp-solid" | "sharp-thin" | "solid" | "thin") | undefined;
+        iconLibrary?: ("fontawesome" | "lucide") | undefined;
+        ariaLabel?: string | undefined;
+    }) => import("react/jsx-runtime").JSX.Element;
+};
+export declare function useMDXComponents(): MDXComponents;

package/dist/mintlify-components.js

@@ -0,0 +1,65 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Accordion, Badge, Callout, Card, Check, CodeBlock, CodeGroup, Color, Columns, Danger, Expandable, Frame, Icon, Info, Mermaid, Note, Panel, Property, Steps, Tabs, Tile, Tip, Tooltip, Tree, Update, Warning, } from '@mintlify/components';
+const Wrapper = ({ children }) => (_jsx("div", { children: children }));
+const MintlifyComponents = {
+    Accordion,
+    Badge,
+    Callout,
+    Card,
+    Check,
+    CodeBlock,
+    CodeGroup,
+    Color,
+    Columns,
+    Danger,
+    Expandable,
+    Frame,
+    Icon,
+    Info,
+    Mermaid,
+    Note,
+    Panel,
+    Property,
+    Steps,
+    Tabs,
+    Tile,
+    Tip,
+    Tooltip,
+    Tree,
+    Update,
+    Warning,
+};
+const placeholderComponents = {
+    AccordionGroup: Wrapper,
+    ApiPlayground: Wrapper,
+    CardGroup: Wrapper,
+    Column: Wrapper,
+    CustomCode: Wrapper,
+    CustomComponent: Wrapper,
+    DynamicCustomComponent: Wrapper,
+    Heading: Wrapper,
+    Latex: Wrapper,
+    Link: Wrapper,
+    Loom: Wrapper,
+    MDXContentController: Wrapper,
+    Param: Wrapper,
+    ParamField: Wrapper,
+    PreviewButton: Wrapper,
+    RequestExample: Wrapper,
+    ResponseExample: Wrapper,
+    ResponseField: Wrapper,
+    Snippet: Wrapper,
+    SnippetGroup: Wrapper,
+    View: Wrapper,
+};
+export const components = {
+    ...MintlifyComponents,
+    ...placeholderComponents,
+};
+export function useMDXComponents() {
+    return {
+        ...components,
+        Step: Steps.Item,
+        Tab: Tabs.Item,
+    };
+}

package/dist/page-context.d.ts

@@ -0,0 +1,53 @@
+import { type DocsConfig } from '@mintlify/validation';
+export interface NavPage {
+    href: string;
+    title: string;
+    icon?: string;
+    tag?: string;
+    api?: string;
+    deprecated?: boolean;
+}
+export interface NavGroup {
+    group: string;
+    pages: NavEntry[];
+    icon?: string;
+    tag?: string;
+}
+export type NavEntry = NavPage | NavGroup;
+export interface TabInfo {
+    name: string;
+    href: string;
+    isActive: boolean;
+}
+export interface PageContext {
+    /** Sidebar entries resolved for the current path */
+    sidebar: NavEntry[];
+    /** Header tabs with active state, or null if nav has no tabs */
+    tabs: TabInfo[] | null;
+    /** Group name the current page belongs to (for breadcrumb / eyebrow) */
+    group: string | null;
+    /** Previous page for footer pagination */
+    prev: NavPage | null;
+    /** Next page for footer pagination */
+    next: NavPage | null;
+}
+/**
+ * Build the navigation context a page needs from `docs.json`.
+ *
+ * ```ts
+ * const page = createPageContext(docsConfig, titleMap, currentPath);
+ *
+ * page.sidebar  // NavEntry[]
+ * page.tabs     // TabInfo[] | null
+ * page.group    // "Getting started"
+ * page.prev     // NavPage | null
+ * page.next     // NavPage | null
+ * ```
+ *
+ * @param docsConfig  The parsed docs.json object.
+ * @param titleMap    A slug→title map, typically built from your content collection.
+ * @param currentPath The current page path (e.g. `"/"` or `"/quickstart"`).
+ */
+export declare function createPageContext(docsConfig: DocsConfig, titleMap: Record<string, string>, currentPath: string): PageContext;
+export declare function isNavPage(entry: NavEntry): entry is NavPage;
+export declare function isNavGroup(entry: NavEntry): entry is NavGroup;

package/dist/page-context.js

@@ -0,0 +1,157 @@
+import { posix, sep } from 'node:path';
+import { divisions } from '@mintlify/validation';
+/**
+ * Build the navigation context a page needs from `docs.json`.
+ *
+ * ```ts
+ * const page = createPageContext(docsConfig, titleMap, currentPath);
+ *
+ * page.sidebar  // NavEntry[]
+ * page.tabs     // TabInfo[] | null
+ * page.group    // "Getting started"
+ * page.prev     // NavPage | null
+ * page.next     // NavPage | null
+ * ```
+ *
+ * @param docsConfig  The parsed docs.json object.
+ * @param titleMap    A slug→title map, typically built from your content collection.
+ * @param currentPath The current page path (e.g. `"/"` or `"/quickstart"`).
+ */
+export function createPageContext(docsConfig, titleMap, currentPath) {
+    const normalizedPath = normalizePath(currentPath);
+    const decoratedNav = decorateNavNode(docsConfig.navigation, titleMap);
+    const sidebar = unwrapNav(decoratedNav, normalizedPath);
+    const tabs = extractTabs(decoratedNav, normalizedPath);
+    const group = findGroup(sidebar, normalizedPath);
+    const { prev, next } = footerPages(sidebar, normalizedPath);
+    return { sidebar, tabs, group, prev, next };
+}
+export function isNavPage(entry) {
+    return 'href' in entry && 'title' in entry;
+}
+export function isNavGroup(entry) {
+    return 'group' in entry && 'pages' in entry;
+}
+function normalizePath(path) {
+    const normalized = posix.normalize(path.split(sep).join(posix.sep));
+    return normalized !== '/' && normalized.endsWith('/')
+        ? normalized.slice(0, -1)
+        : normalized;
+}
+function decorateNavNode(nav, titleMap) {
+    const result = { ...nav };
+    if (Array.isArray(result.pages) && !result.group) {
+        result.pages = result.pages.map((p) => decorateEntry(p, titleMap));
+    }
+    if (Array.isArray(result.groups)) {
+        result.groups = result.groups.map((g) => decorateEntry(g, titleMap));
+    }
+    for (const key of divisions) {
+        const division = result[key];
+        if (Array.isArray(division)) {
+            result[key] = division.map((item) => decorateNavNode(item, titleMap));
+        }
+    }
+    return result;
+}
+function decorateEntry(entry, titleMap) {
+    if (typeof entry === 'string') {
+        return {
+            href: entry === 'index' ? '/' : `/${entry}`,
+            title: titleMap[entry] ?? slugToTitle(entry),
+        };
+    }
+    if (typeof entry === 'object' && entry !== null) {
+        const node = entry;
+        if (node.group != null && Array.isArray(node.pages)) {
+            return {
+                ...node,
+                pages: node.pages.map((page) => decorateEntry(page, titleMap)),
+            };
+        }
+    }
+    return entry;
+}
+function slugToTitle(slug) {
+    const last = slug.split('/').pop() ?? slug;
+    return last
+        .split('-')
+        .map((w) => w.charAt(0).toUpperCase() + w.slice(1))
+        .join(' ');
+}
+function unwrapNav(nav, currentPath) {
+    if (Array.isArray(nav.groups))
+        return nav.groups;
+    if (Array.isArray(nav.pages) && !nav.group)
+        return nav.pages;
+    for (const key of divisions) {
+        const arr = nav[key];
+        if (!Array.isArray(arr))
+            continue;
+        for (const item of arr) {
+            const entries = unwrapNav(item, currentPath);
+            if (entries.length > 0 && containsPath(entries, currentPath))
+                return entries;
+        }
+        if (arr.length > 0)
+            return unwrapNav(arr[0], currentPath);
+    }
+    return [];
+}
+function containsPath(entries, path) {
+    return entries.some((e) => isNavPage(e)
+        ? e.href === path
+        : isNavGroup(e) && containsPath(e.pages, path));
+}
+function extractTabs(nav, currentPath) {
+    if (!Array.isArray(nav.tabs))
+        return null;
+    return nav.tabs.map((tab) => {
+        const entries = unwrapNav(tab, currentPath);
+        return {
+            name: tab.tab ?? '',
+            href: findFirstPage(entries)?.href ?? '/',
+            isActive: containsPath(entries, currentPath),
+        };
+    });
+}
+function findFirstPage(entries) {
+    for (const entry of entries) {
+        if (isNavPage(entry))
+            return entry;
+        if (isNavGroup(entry)) {
+            const page = findFirstPage(entry.pages);
+            if (page)
+                return page;
+        }
+    }
+    return undefined;
+}
+function findGroup(entries, path) {
+    for (const entry of entries) {
+        if (isNavGroup(entry)) {
+            for (const page of entry.pages) {
+                if (isNavPage(page) && page.href === path)
+                    return entry.group;
+                if (isNavGroup(page)) {
+                    const nested = findGroup([page], path);
+                    if (nested)
+                        return nested;
+                }
+            }
+        }
+    }
+    return null;
+}
+function footerPages(entries, currentPath) {
+    const flat = (function flatten(e) {
+        return e.flatMap((x) => (isNavGroup(x) ? flatten(x.pages) : [x]));
+    })(entries);
+    const idx = flat.findIndex((p) => p.href === currentPath);
+    if (idx === -1)
+        return { prev: null, next: null };
+    return {
+        prev: idx > 0 ? flat[idx - 1] : null,
+        next: idx < flat.length - 1 ? flat[idx + 1] : null,
+    };
+}

package/dist/utils/mintlify-components.d.ts

@@ -12,7 +12,7 @@ export declare const components: {
         className?: string | undefined;
         color?: string | undefined;
         icon?: ReactNode;
-        iconType?: ("brands" | "duotone" | "light" | "regular" | "sharp-duotone-solid" | "sharp-light" | "sharp-regular" | "sharp-solid" | "sharp-thin" | "solid" | "thin") | undefined;
+        iconType?: ("light" | "brands" | "duotone" | "regular" | "sharp-duotone-solid" | "sharp-light" | "sharp-regular" | "sharp-solid" | "sharp-thin" | "solid" | "thin") | undefined;
         iconLibrary?: ("fontawesome" | "lucide") | undefined;
         ariaLabel?: string | undefined;
     }) => import("react/jsx-runtime").JSX.Element;
@@ -29,7 +29,7 @@ export declare const components: {
         className?: string | undefined;
         color?: string | undefined;
         icon?: ReactNode;
-        iconType?: ("brands" | "duotone" | "light" | "regular" | "sharp-duotone-solid" | "sharp-light" | "sharp-regular" | "sharp-solid" | "sharp-thin" | "solid" | "thin") | undefined;
+        iconType?: ("light" | "brands" | "duotone" | "regular" | "sharp-duotone-solid" | "sharp-light" | "sharp-regular" | "sharp-solid" | "sharp-thin" | "solid" | "thin") | undefined;
         iconLibrary?: ("fontawesome" | "lucide") | undefined;
         ariaLabel?: string | undefined;
     }) => import("react/jsx-runtime").JSX.Element;
@@ -41,7 +41,7 @@ export declare const components: {
         className?: string | undefined;
         color?: string | undefined;
         icon?: ReactNode;
-        iconType?: ("brands" | "duotone" | "light" | "regular" | "sharp-duotone-solid" | "sharp-light" | "sharp-regular" | "sharp-solid" | "sharp-thin" | "solid" | "thin") | undefined;
+        iconType?: ("light" | "brands" | "duotone" | "regular" | "sharp-duotone-solid" | "sharp-light" | "sharp-regular" | "sharp-solid" | "sharp-thin" | "solid" | "thin") | undefined;
         iconLibrary?: ("fontawesome" | "lucide") | undefined;
         ariaLabel?: string | undefined;
     }) => import("react/jsx-runtime").JSX.Element;
@@ -51,7 +51,7 @@ export declare const components: {
         className?: string | undefined;
         color?: string | undefined;
         icon?: ReactNode;
-        iconType?: ("brands" | "duotone" | "light" | "regular" | "sharp-duotone-solid" | "sharp-light" | "sharp-regular" | "sharp-solid" | "sharp-thin" | "solid" | "thin") | undefined;
+        iconType?: ("light" | "brands" | "duotone" | "regular" | "sharp-duotone-solid" | "sharp-light" | "sharp-regular" | "sharp-solid" | "sharp-thin" | "solid" | "thin") | undefined;
         iconLibrary?: ("fontawesome" | "lucide") | undefined;
         ariaLabel?: string | undefined;
     }) => import("react/jsx-runtime").JSX.Element;
@@ -70,7 +70,7 @@ export declare const components: {
         className?: string | undefined;
         color?: string | undefined;
         icon?: ReactNode;
-        iconType?: ("brands" | "duotone" | "light" | "regular" | "sharp-duotone-solid" | "sharp-light" | "sharp-regular" | "sharp-solid" | "sharp-thin" | "solid" | "thin") | undefined;
+        iconType?: ("light" | "brands" | "duotone" | "regular" | "sharp-duotone-solid" | "sharp-light" | "sharp-regular" | "sharp-solid" | "sharp-thin" | "solid" | "thin") | undefined;
         iconLibrary?: ("fontawesome" | "lucide") | undefined;
         ariaLabel?: string | undefined;
     }) => import("react/jsx-runtime").JSX.Element;
@@ -113,7 +113,7 @@ export declare const components: {
         className?: string | undefined;
         color?: string | undefined;
         icon?: ReactNode;
-        iconType?: ("brands" | "duotone" | "light" | "regular" | "sharp-duotone-solid" | "sharp-light" | "sharp-regular" | "sharp-solid" | "sharp-thin" | "solid" | "thin") | undefined;
+        iconType?: ("light" | "brands" | "duotone" | "regular" | "sharp-duotone-solid" | "sharp-light" | "sharp-regular" | "sharp-solid" | "sharp-thin" | "solid" | "thin") | undefined;
         iconLibrary?: ("fontawesome" | "lucide") | undefined;
         ariaLabel?: string | undefined;
     }) => import("react/jsx-runtime").JSX.Element;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mintlify/astro",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "description": "Mintlify integration for Astro",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -17,6 +17,10 @@
     "./components": {
       "types": "./dist/components.d.ts",
       "import": "./dist/components.js"
+    },
+    "./helpers": {
+      "types": "./dist/helpers.d.ts",
+      "import": "./dist/helpers.js"
     }
   },
   "scripts": {