@admin-layout/tailwind-ui 12.2.4-alpha.4 → 12.2.4-alpha.41

package/lib/components/Markdown/MarkdownNavigation.js

@@ -0,0 +1,38 @@
+import {jsxs,jsx}from'react/jsx-runtime';import {Link}from'@remix-run/react';import'../../utils/isBrowser/index.js';import {cn}from'../../utils/util.js';import'react';import'fast-deep-equal/react.js';const MarkdownNavigation = ({
+  previousMarkdown,
+  nextMarkdown,
+  className,
+  getMarkdownLink
+}) => {
+  if (!previousMarkdown && !nextMarkdown) {
+    return null;
+  }
+  return jsxs("div", {
+    className: cn('mt-16 pt-8 border-t border-border grid grid-cols-1 md:grid-cols-2 gap-6', className),
+    children: [previousMarkdown ? jsxs(Link, {
+      to: getMarkdownLink(previousMarkdown.categoryId, previousMarkdown.slug),
+      className: cn('group rounded-lg border border-border bg-background px-6 py-5', 'hover:bg-muted/30 transition-colors'),
+      children: [jsx("div", {
+        className: "text-sm text-muted-foreground mb-1",
+        children: "Previous"
+      }), jsxs("div", {
+        className: "text-primary font-semibold group-hover:underline text-base",
+        children: ["\u00AB ", previousMarkdown.title]
+      })]
+    }) : jsx("div", {
+      className: "hidden md:block"
+    }), nextMarkdown ? jsxs(Link, {
+      to: getMarkdownLink(nextMarkdown.categoryId, nextMarkdown.slug),
+      className: cn('group rounded-lg border border-border bg-background px-6 py-5', 'hover:bg-muted/30 transition-colors md:text-right'),
+      children: [jsx("div", {
+        className: "text-sm text-muted-foreground mb-1",
+        children: "Next"
+      }), jsxs("div", {
+        className: "text-primary font-semibold group-hover:underline text-base",
+        children: [nextMarkdown.title, " \u00BB"]
+      })]
+    }) : jsx("div", {
+      className: "hidden md:block"
+    })]
+  });
+};export{MarkdownNavigation};//# sourceMappingURL=MarkdownNavigation.js.map

package/lib/components/Markdown/MarkdownNavigation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MarkdownNavigation.js","sources":["../../../src/components/Markdown/MarkdownNavigation.tsx"],"sourcesContent":[null],"names":["_jsxs"],"mappings":"gOAMiB,GAAA,CAAA;kBACC;AACjB,EAAA,YAAA;AAED,EAAA,SAAU;AACN,EAAA;AACA,CAAA,KAAA;MACA,CAAA,gBAAmB,IAAA,CAAA,YAAA,EAAA;IACnB,OAAA,IAAA;AACH,EAAA;AAED,EAAA,OAAAA,IAAA,CAAO,KAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/lib/components/Markdown/MarkdownPage.d.ts

@@ -0,0 +1,41 @@
+import React from 'react';
+export interface Heading {
+    id: string;
+    text: string;
+    level: number;
+}
+export interface Markdown {
+    id: string;
+    title: string;
+    description: string;
+    slug: string;
+    author: string;
+    updatedAt: string;
+    categoryId: string;
+    content: string;
+    htmlContent: string;
+    headings: Heading[];
+}
+export interface NavigationItem {
+    categoryId: string;
+    slug: string;
+    title: string;
+}
+interface MarkdownPageProps {
+    article?: Markdown | null;
+    categoryId?: string;
+    categoryTitle?: string;
+    articleSlug?: string;
+    loadArticle?: (slug: string) => Promise<Markdown | null>;
+    previousMarkdown?: NavigationItem | null;
+    nextMarkdown?: NavigationItem | null;
+    getMarkdownLink: (categoryId: string, slug: string) => string;
+    getCategoryLink: (categoryId: string) => string;
+    getHelpCenterLink: () => string;
+    helpCenterLabel: string;
+    backToHelpCenterLabel?: string;
+    className?: string;
+}
+export declare const MarkdownPage: React.FC<MarkdownPageProps>;
+export {};
+//# sourceMappingURL=MarkdownPage.d.ts.map

package/lib/components/Markdown/MarkdownPage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MarkdownPage.d.ts","sourceRoot":"","sources":["../../../src/components/Markdown/MarkdownPage.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAsC,MAAM,OAAO,CAAC;AAS3D,MAAM,WAAW,OAAO;IACpB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,QAAQ;IACrB,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,OAAO,EAAE,CAAC;CACvB;AAED,MAAM,WAAW,cAAc;IAC3B,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;CACjB;AAED,UAAU,iBAAiB;IACvB,OAAO,CAAC,EAAE,QAAQ,GAAG,IAAI,CAAC;IAC1B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,WAAW,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,QAAQ,GAAG,IAAI,CAAC,CAAC;IACzD,gBAAgB,CAAC,EAAE,cAAc,GAAG,IAAI,CAAC;IACzC,YAAY,CAAC,EAAE,cAAc,GAAG,IAAI,CAAC;IACrC,eAAe,EAAE,CAAC,UAAU,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,KAAK,MAAM,CAAC;IAC9D,eAAe,EAAE,CAAC,UAAU,EAAE,MAAM,KAAK,MAAM,CAAC;IAChD,iBAAiB,EAAE,MAAM,MAAM,CAAC;IAChC,eAAe,EAAE,MAAM,CAAC;IACxB,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAC/B,SAAS,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,eAAO,MAAM,YAAY,EAAE,KAAK,CAAC,EAAE,CAAC,iBAAiB,CAwQpD,CAAC"}

package/lib/components/Markdown/MarkdownPage.js

@@ -0,0 +1,238 @@
+import {jsx,jsxs}from'react/jsx-runtime';import {useState,useRef,useEffect}from'react';import {Link}from'@remix-run/react';import'../../utils/isBrowser/index.js';import {cn}from'../../utils/util.js';import'fast-deep-equal/react.js';import {MarkdownTableOfContents}from'./MarkdownTableOfContents.js';import {MarkdownNavigation}from'./MarkdownNavigation.js';import {MarkdownBreadcrumbs}from'./MarkdownBreadcrumbs.js';import {MarkdownCopyButton}from'./MarkdownCopyButton.js';const MarkdownPage = ({
+  article: articleProp,
+  categoryId: categoryIdProp,
+  categoryTitle: categoryTitleProp,
+  articleSlug,
+  loadArticle,
+  previousMarkdown: previousMarkdownProp,
+  nextMarkdown: nextMarkdownProp,
+  getMarkdownLink,
+  getCategoryLink,
+  getHelpCenterLink,
+  helpCenterLabel,
+  backToHelpCenterLabel,
+  className
+}) => {
+  const [article, setArticle] = useState(articleProp || null);
+  const [loading, setLoading] = useState(!articleProp && !!articleSlug);
+  const [activeHeadingId, setActiveHeadingId] = useState('');
+  const observerRef = useRef(null);
+  const isScrollingRef = useRef(false);
+  const scrollTimeoutRef = useRef(null);
+  useEffect(() => {
+    if (articleProp) {
+      setArticle(articleProp);
+      setLoading(false);
+    } else if (articleSlug && loadArticle) {
+      const loadContent = async () => {
+        const articleData = await loadArticle(articleSlug);
+        setArticle(articleData);
+        setLoading(false);
+      };
+      loadContent();
+    } else if (!articleProp && !articleSlug) {
+      setLoading(false);
+    }
+  }, [articleProp, articleSlug, loadArticle]);
+  // Scroll spy functionality
+  useEffect(() => {
+    if (!article?.headings || article.headings.length === 0) return;
+    // Clean up previous observer
+    if (observerRef.current) {
+      observerRef.current.disconnect();
+    }
+    // Create new intersection observer
+    observerRef.current = new IntersectionObserver(entries => {
+      // Don't update if we're programmatically scrolling
+      if (isScrollingRef.current) return;
+      // Find the heading that's most visible in the viewport
+      const visibleEntries = entries.filter(entry => entry.isIntersecting);
+      if (visibleEntries.length === 0) return;
+      // Find the heading that's closest to the top of the viewport (within the top 30%)
+      // Prioritize headings that are in the upper portion of the viewport
+      let bestEntry = visibleEntries[0];
+      let bestScore = Infinity;
+      visibleEntries.forEach(entry => {
+        const rect = entry.boundingClientRect;
+        const viewportHeight = window.innerHeight;
+        const top30Percent = viewportHeight * 0.3;
+        // Calculate a score: lower is better
+        // Headings in the top 30% of viewport get priority
+        let score;
+        if (rect.top >= 0 && rect.top <= top30Percent) {
+          // Heading is in the top 30% - prioritize by distance from top
+          score = rect.top;
+        } else if (rect.top >= 0) {
+          // Heading is below top 30% but visible - lower priority
+          score = 1000 + rect.top;
+        } else {
+          // Heading is above viewport - lowest priority unless it's the only one
+          score = 2000 + Math.abs(rect.top);
+        }
+        if (score < bestScore) {
+          bestScore = score;
+          bestEntry = entry;
+        }
+      });
+      setActiveHeadingId(bestEntry.target.id);
+    }, {
+      rootMargin: '-10% 0px -70% 0px',
+      threshold: [0, 0.1, 0.5, 1]
+    });
+    // Observe all headings
+    article.headings.forEach(heading => {
+      const element = document.getElementById(heading.id);
+      if (element && observerRef.current) {
+        observerRef.current.observe(element);
+      }
+    });
+    // Cleanup function
+    return () => {
+      if (observerRef.current) {
+        observerRef.current.disconnect();
+      }
+      if (scrollTimeoutRef.current) {
+        clearTimeout(scrollTimeoutRef.current);
+      }
+    };
+  }, [article]);
+  if (loading) {
+    return jsx("div", {
+      className: "min-h-screen bg-background text-foreground overflow-x-hidden",
+      children: jsx("div", {
+        className: "w-full max-w-[90rem] mx-auto px-4 sm:px-6 lg:px-8 xl:px-16 py-16",
+        children: jsxs("div", {
+          className: "animate-pulse",
+          children: [jsx("div", {
+            className: "h-8 bg-muted rounded w-1/3 mb-4"
+          }), jsx("div", {
+            className: "h-4 bg-muted rounded w-1/2 mb-8"
+          }), jsxs("div", {
+            className: "space-y-4",
+            children: [jsx("div", {
+              className: "h-4 bg-muted rounded"
+            }), jsx("div", {
+              className: "h-4 bg-muted rounded w-5/6"
+            }), jsx("div", {
+              className: "h-4 bg-muted rounded w-4/6"
+            })]
+          })]
+        })
+      })
+    });
+  }
+  if (!article) {
+    return jsx("div", {
+      className: "min-h-screen bg-background text-foreground mt-20 overflow-x-hidden",
+      children: jsxs("div", {
+        className: "w-full max-w-[90rem] mx-auto px-4 sm:px-6 lg:px-8 xl:px-16 py-16",
+        children: [jsx("h1", {
+          className: "text-2xl font-bold",
+          children: "Article not found"
+        }), jsx(Link, {
+          to: getHelpCenterLink(),
+          className: "mt-4 text-primary hover:text-primary/80",
+          children: backToHelpCenterLabel || `← Back to ${helpCenterLabel}`
+        })]
+      })
+    });
+  }
+  // Use previous/next articles from props
+  const previousMarkdown = previousMarkdownProp;
+  const nextMarkdown = nextMarkdownProp;
+  return jsx("div", {
+    className: cn('min-h-screen bg-background text-foreground scroll-smooth overflow-x-hidden', className),
+    children: jsxs("div", {
+      className: "flex w-full justify-center gap-10",
+      children: [jsxs("div", {
+        className: "flex-1  max-w-3xl w-full",
+        children: [jsxs("div", {
+          className: "flex items-center justify-between",
+          children: [jsx(MarkdownBreadcrumbs, {
+            categoryId: article.categoryId || categoryIdProp || '',
+            categoryTitle: categoryTitleProp,
+            markdownTitle: article.title,
+            className: "pb-4",
+            getHelpCenterLink: getHelpCenterLink,
+            getCategoryLink: getCategoryLink,
+            helpCenterLabel: helpCenterLabel
+          }), jsx(MarkdownCopyButton, {
+            markdownTitle: article.title,
+            markdownContent: article.htmlContent,
+            className: "flex-shrink-0"
+          })]
+        }), jsx("main", {
+          className: "w-full py-2",
+          children: jsx("div", {
+            className: "max-w-[90rem] mx-auto px-4 sm:px-6 lg:px-8 xl:px-16 relative",
+            children: jsx("div", {
+              className: "flex flex-col xl:flex-row gap-12 xl:gap-16 align-start",
+              children: jsxs("div", {
+                className: "flex-1 min-w-0 max-w-5xl",
+                children: [jsx("div", {
+                  className: "prose prose-lg max-w-none w-full overflow-x-hidden",
+                  children: jsx("div", {
+                    className: cn(
+                    // Base prose styles
+                    'prose-headings:font-semibold prose-headings:text-foreground prose-headings:tracking-tight',
+                    // Body H1 styles (within article) - slightly smaller than page title
+                    'prose-h1:text-[1.5rem] prose-h1:md:text-[1.75rem] prose-h1:mb-4 prose-h1:mt-5 prose-h1:leading-tight',
+                    // H2 styles - strong section headings
+                    'prose-h2:text-[1.2rem] prose-h2:md:text-[1.5rem] prose-h2:mb-4 prose-h2:mt-5 prose-h2:leading-tight',
+                    // H3 styles - sub section headings
+                    'prose-h3:text-[1.05rem] prose-h3:md:text-[1.25rem] prose-h3:mb-3 prose-h3:mt-4 prose-h3:leading-snug',
+                    // H4 styles
+                    'prose-h4:text-lg prose-h4:md:text-xl prose-h4:mb-3 prose-h4:mt-4',
+                    // Paragraph styles
+                    'prose-p:text-[0.85rem] prose-p:md:text-[0.95rem] prose-p:text-muted-foreground prose-p:leading-relaxed prose-p:mb-5',
+                    // Strong text
+                    'prose-strong:text-foreground prose-strong:font-semibold',
+                    // Links
+                    'prose-a:text-primary prose-a:no-underline hover:prose-a:underline prose-a:font-medium',
+                    // Lists
+                    'prose-ul:text-muted-foreground prose-ol:text-muted-foreground prose-li:text-muted-foreground prose-li:mb-2 prose-li:text-base prose-li:md:text-lg',
+                    // Blockquotes
+                    'prose-blockquote:text-muted-foreground prose-blockquote:border-l-primary prose-blockquote:pl-4 prose-blockquote:my-6',
+                    // Code
+                    'prose-code:text-foreground prose-code:bg-muted prose-code:px-1.5 prose-code:py-0.5 prose-code:rounded prose-code:text-sm prose-code:font-mono',
+                    // Pre blocks
+                    'prose-pre:bg-muted prose-pre:text-foreground prose-pre:overflow-x-auto prose-pre:rounded-lg prose-pre:p-4 prose-pre:my-6',
+                    // Images
+                    'prose-img:rounded-lg prose-img:my-8',
+                    // Tables
+                    'prose-table:text-muted-foreground prose-th:text-foreground prose-th:font-semibold',
+                    // Horizontal rules
+                    'prose-hr:border-border prose-hr:my-8'),
+                    dangerouslySetInnerHTML: {
+                      __html: article.htmlContent
+                    }
+                  })
+                }), jsx(MarkdownNavigation, {
+                  previousMarkdown: previousMarkdown,
+                  nextMarkdown: nextMarkdown,
+                  getMarkdownLink: getMarkdownLink
+                })]
+              })
+            })
+          })
+        })]
+      }), jsx(MarkdownTableOfContents, {
+        headings: article.headings || [],
+        activeHeadingId: activeHeadingId,
+        onHeadingClick: headingId => {
+          // Set scrolling flag to prevent observer from overriding
+          isScrollingRef.current = true;
+          setActiveHeadingId(headingId);
+          // Clear any existing timeout
+          if (scrollTimeoutRef.current) {
+            clearTimeout(scrollTimeoutRef.current);
+          }
+          // Re-enable observer after scroll completes (smooth scroll takes ~500ms)
+          scrollTimeoutRef.current = setTimeout(() => {
+            isScrollingRef.current = false;
+          }, 800);
+        }
+      })]
+    })
+  });
+};export{MarkdownPage};//# sourceMappingURL=MarkdownPage.js.map

package/lib/components/Markdown/MarkdownPage.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MarkdownPage.js","sources":["../../../src/components/Markdown/MarkdownPage.tsx"],"sourcesContent":[null],"names":[],"mappings":"wdAkBI,MAAA,YAAoB,GAAA,CAAA;SAChB,aAAS;YACL,gBAAO;eACJ,mBAAO;aAClB;aACS;wCACW;cACV,EAAA,gBAAU;AACvB,EAAA,eAAA;AAED,EAAA,eAAiB;;iBAEA;uBACC;AACjB,EAAA;AAED,CAAA,KAAA;AACI,EAAA,MAAA,CAAA,OAAU,EAAA,WAAe,GAAC,QAAA,CAAA,WAAA,IAAA,IAAA,CAAA;QAC1B,CAAA,OAAW,EAAE,UAAO,CAAA,GAAA,QAAA,CAAA,CAAA,WAAA,IAAA,CAAA,CAAA,WAAA,CAAA;QACpB,CAAA,eAAgB,EAAM,kBAAC,CAAA,GAAA,QAAA,CAAA,EAAA,CAAA;QACvB,WAAc,GAAA,MAAO,CAAA,IAAA,CAAA;AACrB,EAAA,MAAA,cAAe,GAAM,MAAM,CAAA,KAAK,CAAA;AAChC,EAAA,MAAA,gBAAmB,GAAA,MAAA,CAAA,IAAc,CAAA;AACjC,EAAA,SAAA,CAAA,MAAa;IACb,IAAA,WAAe,EAAE;AACjB,MAAA,UAAA,CAAA,WAAkB,CAAA;MAClB,UAAA,CAAA,KAAiB,CAAE;IACnB,CAAA,MAAA,IAAA,eAAwB,WAAA,EAAA;MACxB,MAAA,WAAA,GAAsB,YAAS;QAC/B,MAAU,WAAS,GAAA,MAAA,WAAA,CAAA,WAAA,CAAA;AACtB,QAAA,UAAA,CAAA,WAAA,CAAA;AAED,QAAA,UAAO,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/lib/components/Markdown/MarkdownTableOfContents.d.ts

@@ -0,0 +1,15 @@
+import React from 'react';
+interface Heading {
+    id: string;
+    text: string;
+    level: number;
+}
+interface MarkdownTableOfContentsProps {
+    headings: Heading[];
+    activeHeadingId: string;
+    onHeadingClick?: (headingId: string) => void;
+    className?: string;
+}
+export declare const MarkdownTableOfContents: React.FC<MarkdownTableOfContentsProps>;
+export {};
+//# sourceMappingURL=MarkdownTableOfContents.d.ts.map

package/lib/components/Markdown/MarkdownTableOfContents.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MarkdownTableOfContents.d.ts","sourceRoot":"","sources":["../../../src/components/Markdown/MarkdownTableOfContents.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAI1B,UAAU,OAAO;IACb,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;CACjB;AAED,UAAU,4BAA4B;IAClC,QAAQ,EAAE,OAAO,EAAE,CAAC;IACpB,eAAe,EAAE,MAAM,CAAC;IACxB,cAAc,CAAC,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,IAAI,CAAC;IAC7C,SAAS,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,eAAO,MAAM,uBAAuB,EAAE,KAAK,CAAC,EAAE,CAAC,4BAA4B,CA6E1E,CAAC"}

package/lib/components/Markdown/MarkdownTableOfContents.js

@@ -0,0 +1,57 @@
+import {jsx,jsxs}from'react/jsx-runtime';import {Link}from'@remix-run/react';import'../../utils/isBrowser/index.js';import {cn}from'../../utils/util.js';import'react';import'fast-deep-equal/react.js';const MarkdownTableOfContents = ({
+  headings,
+  activeHeadingId,
+  onHeadingClick,
+  className
+}) => {
+  if (!headings || headings.length === 0) {
+    return null;
+  }
+  const handleClick = headingId => {
+    // Immediately set the active heading when clicked
+    if (onHeadingClick) {
+      onHeadingClick(headingId);
+    }
+    // Smooth scroll to the heading with proper offset
+    const element = document.getElementById(headingId);
+    if (element) {
+      // Calculate the position with offset for header
+      const elementPosition = element.getBoundingClientRect().top + window.pageYOffset;
+      const offsetPosition = elementPosition - 100; // 100px offset from top
+      window.scrollTo({
+        top: offsetPosition,
+        behavior: 'smooth'
+      });
+    }
+  };
+  return jsx("aside", {
+    className: "hidden xl:block xl:w-80 xl:flex-shrink-0 max-w-[28rem]",
+    children: jsxs("div", {
+      className: "fixed flex flex-col h-[calc(100vh-3rem)] w-[19rem]",
+      children: [jsx("div", {
+        className: "mb-4 flex-shrink-0",
+        children: jsxs("h2", {
+          className: "text-sm font-semibold text-primary flex items-center",
+          children: [jsx("span", {
+            className: "mr-2",
+            children: "\u2630"
+          }), "On this page"]
+        })
+      }), jsx("nav", {
+        className: "space-y-1 flex-1 overflow-y-auto overflow-x-hidden min-h-0",
+        children: headings.map((heading, index) => {
+          const isActive = activeHeadingId === heading.id;
+          return jsx(Link, {
+            to: `#${heading.id}`,
+            onClick: e => {
+              e.preventDefault();
+              handleClick(heading.id);
+            },
+            className: cn('relative block text-sm transition-colors py-1 pl-4', 'border-l-2 border-transparent', isActive ? 'text-primary border-l-primary bg-muted/20' : 'text-muted-foreground hover:text-primary hover:border-l-primary', heading.level === 1 ? 'font-semibold' : heading.level === 2 ? 'ml-2' : heading.level === 3 ? 'ml-4' : heading.level === 4 ? 'ml-6' : heading.level === 5 ? 'ml-8' : 'ml-10'),
+            children: heading.text
+          }, index);
+        })
+      })]
+    })
+  });
+};export{MarkdownTableOfContents};//# sourceMappingURL=MarkdownTableOfContents.js.map

package/lib/components/Markdown/MarkdownTableOfContents.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MarkdownTableOfContents.js","sources":["../../../src/components/Markdown/MarkdownTableOfContents.tsx"],"sourcesContent":[null],"names":[],"mappings":"qOAMiB,GAAA,CAAA;UACR;AACR,EAAA,eAAA;AAED,EAAA,cAAU;;MAEN;MACA,CAAA,QAAA,IAAe,QAAG,CAAA,MAAW,KAAM,CAAA,EAAA;IACnC,OAAA,IAAU;AACb,EAAA;AAED,EAAA,MAAA,WAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/lib/components/Markdown/index.d.ts

@@ -0,0 +1,7 @@
+export * from './MarkdownBreadcrumbs';
+export * from './MarkdownCopyButton';
+export * from './MarkdownHeader';
+export * from './MarkdownNavigation';
+export * from './MarkdownPage';
+export * from './MarkdownTableOfContents';
+//# sourceMappingURL=index.d.ts.map

package/lib/components/Markdown/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/components/Markdown/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC;AACtC,cAAc,sBAAsB,CAAC;AACrC,cAAc,kBAAkB,CAAC;AACjC,cAAc,sBAAsB,CAAC;AACrC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,2BAA2B,CAAC"}

package/lib/components/OTP/OTPInput.js

@@ -1,4 +1,4 @@
-import React__default from'react';import {useOTPInput}from'./hooks.js';import {SingleInput}from'./SingleInput.js';import {getPlaceholderValue,isInputNumeric}from'./utils.js';const OTPInput = ({
+import {jsx,jsxs}from'react/jsx-runtime';import React__default from'react';import {useOTPInput}from'./hooks.js';import {SingleInput}from'./SingleInput.js';import {getPlaceholderValue,isInputNumeric}from'./utils.js';const OTPInput = ({
   value = '',
   numInputs = 4,
   onChange,
@@ -23,7 +23,7 @@ import React__default from'react';import {useOTPInput}from'./hooks.js';import {S
     handlePaste
   }, inputRefs] = useOTPInput(value, numInputs, onChange, inputType, shouldAutoFocus);
   // Create default input renderer if not provided
-  const defaultRenderInput = (props, index) => React__default.createElement(SingleInput, {
+  const defaultRenderInput = (props, index) => jsx(SingleInput, {
     ...props,
     focused: activeInput === index
   });
@@ -47,34 +47,36 @@ import React__default from'react';import {useOTPInput}from'./hooks.js';import {S
     // Let the hook handle the paste logic
     handlePaste(e);
   };
-  return React__default.createElement("div", {
+  return jsx("div", {
     className: `flex items-center justify-center space-x-2 md:space-x-4 ${containerClassName || ''}`,
     onPaste: handleComponentPaste,
-    "data-testid": "otp-input-container"
-  }, Array.from({
-    length: numInputs
-  }, (_, index) => React__default.createElement(React__default.Fragment, {
-    key: index
-  }, inputRenderer({
-    value: otp[index] || '',
-    placeholder: placeholderValue?.[index],
-    ref: element => {
-      if (inputRefs.current) {
-        inputRefs.current[index] = element;
-      }
-    },
-    onChange: handleChange,
-    onFocus: event => handleFocus(event)(index),
-    onBlur: handleBlur,
-    onKeyDown: handleKeyDown,
-    onPaste: handlePaste,
-    autoComplete: 'off',
-    'aria-label': `Please enter OTP character ${index + 1}`,
-    className: skipDefaultStyles ? inputClassName || '' : `${inputClassName || ''}`,
-    type: inputType,
-    inputMode: isInputNum ? 'numeric' : 'text',
-    onInput: handleInputChange
-  }, index), index < numInputs - 1 && (typeof renderSeparator === 'function' ? renderSeparator(index) : renderSeparator || React__default.createElement("span", {
-    className: "text-gray-400"
-  }, "-")))));
+    "data-testid": "otp-input-container",
+    children: Array.from({
+      length: numInputs
+    }, (_, index) => jsxs(React__default.Fragment, {
+      children: [inputRenderer({
+        value: otp[index] || '',
+        placeholder: placeholderValue?.[index],
+        ref: element => {
+          if (inputRefs.current) {
+            inputRefs.current[index] = element;
+          }
+        },
+        onChange: handleChange,
+        onFocus: event => handleFocus(event)(index),
+        onBlur: handleBlur,
+        onKeyDown: handleKeyDown,
+        onPaste: handlePaste,
+        autoComplete: 'off',
+        'aria-label': `Please enter OTP character ${index + 1}`,
+        className: skipDefaultStyles ? inputClassName || '' : `${inputClassName || ''}`,
+        type: inputType,
+        inputMode: isInputNum ? 'numeric' : 'text',
+        onInput: handleInputChange
+      }, index), index < numInputs - 1 && (typeof renderSeparator === 'function' ? renderSeparator(index) : renderSeparator || jsx("span", {
+        className: "text-gray-400",
+        children: "-"
+      }))]
+    }, index))
+  });
 };export{OTPInput};//# sourceMappingURL=OTPInput.js.map

package/lib/components/OTP/OTPInput.js.map

@@ -1 +1 @@
-{"version":3,"file":"OTPInput.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"OTPInput.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}