boltdocs 2.7.10 → 2.7.11

package/src/client/hooks/use-search-highlight.ts

@@ -1,185 +0,0 @@
-import { useEffect } from 'react'
-import { useLocation } from './use-location'
-
-/**
- * Hook to highlight search terms based on the 'hl' query parameter.
- */
-export function useSearchHighlight(
-  containerSelector: string = '.boltdocs-page',
-) {
-  const { search } = useLocation()
-  const query = new URLSearchParams(search).get('hl')
-
-  useEffect(() => {
-    if (!query) {
-      clearHighlights(containerSelector)
-      return
-    }
-
-    const container = document.querySelector(containerSelector)
-    if (!container) return
-
-    let rafId: number
-
-    // Observe changes to the content (e.g. navigation or lazy loading)
-    const observer = new MutationObserver((mutations) => {
-      const hasExternalChanges = mutations.some((m) => {
-        const addedNodes = Array.from(m.addedNodes)
-        const removedNodes = Array.from(m.removedNodes)
-
-        return (
-          addedNodes.some(
-            (n) =>
-              !(
-                n instanceof HTMLElement &&
-                n.hasAttribute('data-search-highlight')
-              ),
-          ) ||
-          removedNodes.some(
-            (n) =>
-              !(
-                n instanceof HTMLElement &&
-                n.hasAttribute('data-search-highlight')
-              ),
-          )
-        )
-      })
-
-      if (hasExternalChanges) {
-        run()
-      }
-    })
-
-    // Function to run highlighting
-    function run() {
-      cancelAnimationFrame(rafId)
-      rafId = requestAnimationFrame(() => {
-        // Disconnect to avoid observing our own cleanup/highlight cycle
-        observer.disconnect()
-        clearHighlights(containerSelector)
-
-        // Split query into individual words (minimum 2 chars)
-        const terms = query!
-          .split(/\s+/)
-          .map((t) => t.trim())
-          .filter((t) => t.length >= 2)
-
-        if (terms.length > 0) {
-          highlightTerms(container!, terms)
-        }
-
-        // Re-observe
-        observer.observe(container!, { childList: true, subtree: true })
-      })
-    }
-
-    // Initial run
-    run()
-
-    return () => {
-      cancelAnimationFrame(rafId)
-      observer.disconnect()
-      clearHighlights(containerSelector)
-    }
-  }, [query, search, containerSelector])
-}
-
-function clearHighlights(selector: string) {
-  const marks = document.querySelectorAll(
-    `${selector} mark[data-search-highlight]`,
-  )
-  marks.forEach((mark) => {
-    try {
-      const parent = mark.parentNode
-      if (parent && parent.contains(mark)) {
-        const text = mark.textContent || ''
-        parent.replaceChild(document.createTextNode(text), mark)
-      }
-    } catch (e) {
-      // Ignore DOM errors during cleanup
-    }
-  })
-}
-
-function highlightTerms(container: Element, terms: string[]) {
-  const walker = document.createTreeWalker(container, NodeFilter.SHOW_TEXT, {
-    acceptNode: (node) => {
-      const parent = node.parentElement
-      if (
-        parent &&
-        (parent.tagName === 'SCRIPT' ||
-          parent.tagName === 'STYLE' ||
-          parent.tagName === 'MARK' ||
-          parent.closest('pre') ||
-          parent.closest('code'))
-      ) {
-        return NodeFilter.FILTER_REJECT
-      }
-      return NodeFilter.FILTER_ACCEPT
-    },
-  })
-
-  const nodes: Text[] = []
-  let node: Node | null
-  while ((node = walker.nextNode())) {
-    nodes.push(node as Text)
-  }
-
-  // Create a combined regex for all terms
-  // Accent-insensitive helper: replaces 'a' with '[aáàä...]'
-  const accentMap: Record<string, string> = {
-    a: '[aáàäâã]',
-    e: '[eéèëê]',
-    i: '[iíìïî]',
-    o: '[oóòöôõ]',
-    u: '[uúùüû]',
-    n: '[nñ]',
-    c: '[cç]',
-  }
-
-  const prepareRegex = (term: string) => {
-    let pattern = term.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
-    // Make it accent insensitive
-    pattern = pattern
-      .split('')
-      .map((char) => {
-        const lower = char.toLowerCase()
-        return accentMap[lower] || char
-      })
-      .join('')
-    return pattern
-  }
-
-  const combinedPattern = terms.map(prepareRegex).join('|')
-  const regex = new RegExp(`(${combinedPattern})`, 'gi')
-
-  const matchRegexes = terms.map((term) => {
-    const p = prepareRegex(term)
-    return new RegExp(`^${p}$`, 'i')
-  })
-
-  nodes.forEach((textNode) => {
-    const text = textNode.textContent
-    if (text && regex.test(text)) {
-      const fragment = document.createDocumentFragment()
-      const parts = text.split(regex)
-
-      parts.forEach((part) => {
-        const isMatch = matchRegexes.some((rx) => rx.test(part))
-
-        if (isMatch) {
-          const mark = document.createElement('mark')
-          mark.textContent = part
-          mark.setAttribute('data-search-highlight', 'true')
-          fragment.appendChild(mark)
-        } else if (part) {
-          fragment.appendChild(document.createTextNode(part))
-        }
-      })
-
-      if (textNode.parentNode) {
-        textNode.parentNode.replaceChild(fragment, textNode)
-      }
-    }
-  })
-}

package/src/client/hooks/use-search.ts

@@ -1,118 +0,0 @@
-import { useState, useMemo, useEffect } from 'react'
-import { Index } from 'flexsearch'
-import { useRoutes } from './use-routes'
-import type { ComponentRoute } from '../types'
-// @ts-expect-error
-import searchData from 'virtual:boltdocs-search'
-
-interface SearchDataItem {
-  id: string
-  title: string
-  content: string
-  url: string
-  display: string
-  locale?: string
-  version?: string
-}
-
-export function useSearch(routes: ComponentRoute[]) {
-  const { currentLocale, currentVersion } = useRoutes()
-  const [isOpen, setIsOpen] = useState(false)
-  const [query, setQuery] = useState('')
-  const [index, setIndex] = useState<Index | null>(null)
-
-  // Initialize FlexSearch index once
-  useEffect(() => {
-    if (!isOpen || index) return
-
-    const newIndex = new Index({
-      preset: 'match',
-      tokenize: 'full',
-      resolution: 9,
-      cache: true,
-    })
-
-    // Index all documents
-    for (const doc of searchData as SearchDataItem[]) {
-      newIndex.add(doc.id, `${doc.title} ${doc.content}`)
-    }
-
-    setIndex(newIndex)
-  }, [isOpen, index])
-
-  // Pre-index searchData for O(1) lookups
-  const searchDataMap = useMemo(() => {
-    const map = new Map<string, SearchDataItem>()
-    for (const doc of searchData as SearchDataItem[]) {
-      map.set(doc.id, doc)
-    }
-    return map
-  }, [])
-
-  const list = useMemo(() => {
-    if (!query) {
-      // Default results: just active routes
-      return routes
-        .filter((r) => {
-          const localeMatch = !currentLocale || r.locale === currentLocale
-          const versionMatch = !currentVersion || r.version === currentVersion
-          return localeMatch && versionMatch
-        })
-        .slice(0, 10)
-        .map((r) => ({
-          id: r.path,
-          title: r.title,
-          path: r.path,
-          bio: r.description || '',
-          groupTitle: r.groupTitle,
-        }))
-    }
-
-    if (!index) return []
-
-    const searchResults = index.search(query, {
-      limit: 20,
-      suggest: true,
-    })
-
-    const results: any[] = []
-    const seen = new Set<string>()
-
-    for (const id of searchResults) {
-      const doc = searchDataMap.get(id as string)
-      if (!doc) continue
-
-      // Filter by locale and version
-      const localeMatch = !currentLocale || doc.locale === currentLocale
-      const versionMatch = !currentVersion || doc.version === currentVersion
-      if (!localeMatch || !versionMatch) continue
-
-      if (seen.has(doc.url)) continue
-      seen.add(doc.url)
-
-      results.push({
-        id: doc.url,
-        title: doc.title,
-        path: doc.url,
-        bio: doc.display,
-        groupTitle: doc.display.split(' > ')[0],
-        isHeading: doc.url.includes('#'),
-      })
-    }
-
-    return results.slice(0, 10)
-  }, [query, index, currentLocale, currentVersion, routes, searchDataMap])
-
-  return {
-    isOpen,
-    setIsOpen,
-    query,
-    setQuery,
-    list,
-    input: {
-      value: query,
-      onChange: (e: React.ChangeEvent<HTMLInputElement>) =>
-        setQuery(e.target.value),
-    },
-  }
-}

package/src/client/hooks/use-sidebar.ts

@@ -1,205 +0,0 @@
-import { useMemo } from 'react'
-import { useLocation } from 'react-router-dom'
-import { useConfig } from '../app/config-context'
-import type { ComponentRoute } from '../types'
-import { normalizePath } from '../utils/path'
-
-export function useSidebar(routes: ComponentRoute[]) {
-  const config = useConfig()
-  const location = useLocation()
-
-  const currentPath = normalizePath(location.pathname)
-
-  return useMemo(() => {
-    const activeRoute = routes.find(
-      (r) => normalizePath(r.path) === currentPath,
-    )
-    const activeTabId = activeRoute?.tab?.toLowerCase()
-
-    const filteredRoutes = activeTabId
-      ? routes.filter((r) => !r.tab || r.tab.toLowerCase() === activeTabId)
-      : routes
-
-    const directoryMeta: Record<string, any> = {}
-    if (config.directoryMeta) {
-      for (const [key, value] of Object.entries(config.directoryMeta)) {
-        const cleanKey = key
-          .split('/')
-          .filter((part) => !part.startsWith('(') || !part.endsWith(')'))
-          .map((part) => part.replace(/^\d+-/, ''))
-          .join('/')
-        directoryMeta[cleanKey === '' ? '.' : cleanKey] = value
-      }
-    }
-
-    // 1. Helper to format labels
-    const capitalize = (str: string) =>
-      str.charAt(0).toUpperCase() + str.slice(1).replace(/-/g, ' ')
-
-    // 2. Define recursive tree builder
-    const rootNodesMap = new Map<string, ComponentRoute>()
-    const ungrouped: ComponentRoute[] = []
-
-    // Helper to find or create nested folders recursively
-    const getOrCreateNode = (
-      parts: string[],
-      rootStore: Map<string, ComponentRoute>,
-    ) => {
-      let currentMap = rootStore
-      let parentPath = ''
-      let lastNode: ComponentRoute | null = null
-
-      for (let i = 0; i < parts.length; i++) {
-        const segment = parts[i]
-        const currentRelPath = parentPath ? `${parentPath}/${segment}` : segment
-
-        if (!currentMap.has(segment)) {
-          const meta = directoryMeta[currentRelPath] || {}
-          const newNode: ComponentRoute = {
-            path: '#', // Placeholder
-            title: meta.title || capitalize(segment),
-            componentPath: '',
-            filePath: '',
-            icon: meta.icon,
-            groupPosition: typeof meta.order === 'number' ? meta.order : 999,
-            subRoutes: [],
-          }
-          currentMap.set(segment, newNode)
-        }
-
-        lastNode = currentMap.get(segment)!
-
-        // Create inner subRoutes mapping helper
-        if (!(lastNode as any)._subMap) {
-          ;(lastNode as any)._subMap = new Map<string, ComponentRoute>()
-        }
-        currentMap = (lastNode as any)._subMap as Map<string, ComponentRoute>
-        parentPath = currentRelPath
-      }
-      return lastNode
-    }
-
-    // 3. Sort input routes initially by their internal position/ordering
-    const sortedRoutes = [...filteredRoutes].sort((a, b) => {
-      const posA = a.sidebarPosition ?? a.order ?? 999
-      const posB = b.sidebarPosition ?? b.order ?? 999
-      return posA - posB
-    })
-
-    // 4. Distribute routes into tree
-    for (const route of sortedRoutes) {
-      if (route.sidebarHidden) continue
-
-      const parts = route.slugParts || []
-      const fileName = route.filePath.split('/').pop() || ''
-      const isIndex = /^index\.mdx?$/.test(fileName)
-
-      if (parts.length === 0) {
-        // Top level route (not in subfolder)
-        if (route.filePath) ungrouped.push(route)
-        continue
-      }
-
-      if (isIndex) {
-        // Index files populate the CONTAINER object itself
-        const containerNode = getOrCreateNode(parts, rootNodesMap)
-        if (containerNode) {
-          // Merge properties onto the container so it becomes clickable
-          containerNode.path = route.path
-          containerNode.title = route.title || containerNode.title
-          containerNode.icon = route.icon || containerNode.icon
-          containerNode.badge = route.badge
-          containerNode.sidebarPosition = route.sidebarPosition
-          containerNode.frontmatter = route.frontmatter
-        }
-      } else {
-        // Normal leaf file nested under path
-        const parentNode = getOrCreateNode(parts, rootNodesMap)
-        if (parentNode) {
-          parentNode.subRoutes!.push(route)
-        }
-      }
-    }
-
-    // 5. Recursive sorting and cleanup helper
-    const finalizeTree = (
-      nodes: ComponentRoute[],
-      currentPathPrefix: string = '',
-    ): ComponentRoute[] => {
-      nodes.forEach((node) => {
-        // 1. Pull child nodes from internal Map store into subRoutes
-        if ((node as any)._subMap) {
-          const childDirs = Array.from(
-            ((node as any)._subMap as Map<string, ComponentRoute>).values(),
-          )
-          node.subRoutes = [...(node.subRoutes || []), ...childDirs]
-          delete (node as any)._subMap
-        }
-
-        // 2. Recursively process grandchildren
-        if (node.subRoutes && node.subRoutes.length > 0) {
-          node.subRoutes = finalizeTree(node.subRoutes)
-        }
-      })
-
-      // 3. Sort this specific depth layer
-      return nodes.sort((a, b) => {
-        // Position ordering
-        const posA = a.sidebarPosition ?? a.groupPosition ?? 999
-        const posB = b.sidebarPosition ?? b.groupPosition ?? 999
-
-        if (posA !== posB) return posA - posB
-
-        // Fallback alphabetical
-        return a.title.localeCompare(b.title)
-      })
-    }
-
-    // Finalize top-level groups
-    const rawGroups = Array.from(rootNodesMap.values())
-    const finalizedTopNodes = finalizeTree(rawGroups)
-
-    // Map finalized top nodes to expected format [{ title, routes }]
-    const groups = finalizedTopNodes.map((node) => {
-      // To match current primitives expectations, a 'group' is the top-level container.
-      // If the top node is already structured as a ComponentRoute, we wrap it.
-      return {
-        slug: node.title.toLowerCase().replace(/\s+/g, '-'),
-        title: node.title,
-        icon: node.icon,
-        routes: [node], // The primitives sidebar renderer iterates topGroup.routes and recurses inside.
-      }
-    })
-
-    // Wait, actually the legacy Sidebar.tsx treats "groups" as visual wrappers with headers,
-    // and "routes" inside as the start of items. If we want top-level direct items, they map to 'ungrouped'.
-    // Let's return grouped items natively.
-
-    // RE-DESIGN LEGACY COMPATIBILITY:
-    // If user wants strict backwards layout, we unwrap the very top layer!
-    const legacyCompatibleGroups = finalizedTopNodes
-      .map((node) => {
-        // Check if it's a container with subitems. If it is, make IT the group header!
-        if (node.subRoutes && node.subRoutes.length > 0) {
-          return {
-            slug: node.title.toLowerCase().replace(/\s+/g, '-'),
-            title: node.title,
-            icon: node.icon,
-            routes: node.subRoutes, // Unwrap children as top-level list underneath the visual group title!
-          }
-        }
-        // If it's standalone, send it to ungrouped
-        ungrouped.push(node)
-        return null
-      })
-      .filter(Boolean) as any[]
-
-    return {
-      groups: legacyCompatibleGroups,
-      ungrouped: finalizeTree(ungrouped),
-      activeRoute,
-      activePath: currentPath,
-      config,
-    }
-  }, [routes, config, currentPath])
-}

package/src/client/hooks/use-tabs.ts

@@ -1,46 +0,0 @@
-import { useLocation } from 'react-router-dom'
-import { useEffect, useState, useRef } from 'react'
-import type { ComponentRoute, BoltdocsTab } from '../types'
-import { normalizePath } from '../utils/path'
-
-export function useTabs(
-  tabs: BoltdocsTab[] = [],
-  routes: ComponentRoute[] = [],
-) {
-  const location = useLocation()
-  const tabRefs = useRef<(HTMLAnchorElement | null)[]>([])
-  const [indicatorStyle, setIndicatorStyle] = useState<React.CSSProperties>({
-    opacity: 0,
-    transform: 'translateX(0) scaleX(0)',
-    width: 0,
-  })
-
-  const currentPath = normalizePath(location.pathname)
-
-  const activeRoute = routes.find((r) => normalizePath(r.path) === currentPath)
-  const activeTabId = activeRoute?.tab?.toLowerCase()
-  const activeIndex = tabs.findIndex(
-    (tab) => tab.id.toLowerCase() === activeTabId,
-  )
-  const finalActiveIndex = activeIndex === -1 ? 0 : activeIndex
-
-  // biome-ignore lint/correctness/useExhaustiveDependencies: Updated pointer to the tab
-  useEffect(() => {
-    const activeTab = tabRefs.current[finalActiveIndex]
-    if (activeTab) {
-      setIndicatorStyle({
-        opacity: 1,
-        width: activeTab.offsetWidth,
-        transform: `translateX(${activeTab.offsetLeft}px)`,
-      })
-    }
-  }, [finalActiveIndex, tabs.length, location.pathname])
-
-  return {
-    tabs,
-    activeIndex: finalActiveIndex,
-    indicatorStyle,
-    tabRefs,
-    activeTabId,
-  }
-}

package/src/client/hooks/use-version.ts

@@ -1,111 +0,0 @@
-import { useMemo } from 'react'
-import { useNavigate } from 'react-router-dom'
-import { getBaseFilePath } from '../utils/get-base-file-path'
-import { useRoutes } from './use-routes'
-import { useConfig } from '../app/config-context'
-import { useBoltdocsContext } from '../store/boltdocs-context'
-import type { BoltdocsVersion } from '../../shared/types'
-
-export interface VersionOption {
-  key: BoltdocsVersion
-  label: string
-  value: string
-  isCurrent: boolean
-}
-
-export interface UseVersionReturn {
-  currentVersion: BoltdocsVersion | undefined
-  currentVersionLabel: string | undefined
-  availableVersions: VersionOption[]
-  handleVersionChange: (version: BoltdocsVersion) => void
-}
-
-/**
- * Hook to manage and switch between different versions of the documentation.
- */
-export function useVersion(): UseVersionReturn {
-  const navigate = useNavigate()
-  const config = useConfig()
-  const { allRoutes, currentRoute, currentVersion, currentLocale } = useRoutes()
-  const versions = config.versions
-  const { setVersion } = useBoltdocsContext()
-
-  const handleVersionChange = (version: string) => {
-    if (!versions || version === currentVersion) return
-
-    // Update store
-    setVersion(version)
-
-    // 3. Attempt derivation or deployment of navigation target
-    const base = config.base || '/docs'
-    const safeBase = base.replace(/\/$/, '')
-    let targetPath = `${safeBase}/${version}${currentLocale ? `/${currentLocale}` : ''}`
-
-    if (currentRoute) {
-      const baseFile = getBaseFilePath(
-        currentRoute.filePath,
-        currentRoute.version,
-        currentRoute.locale,
-      )
-
-      const targetRoute = allRoutes.find(
-        (r) =>
-          getBaseFilePath(r.filePath, r.version, r.locale) === baseFile &&
-          (r.version || versions.defaultVersion) === version &&
-          (!config.i18n ||
-            (r.locale || config.i18n.defaultLocale) === currentLocale),
-      )
-
-      if (targetRoute) {
-        targetPath = targetRoute.path
-      } else {
-        const versionIndexRoute = allRoutes.find(
-          (r) =>
-            getBaseFilePath(r.filePath, r.version, r.locale) === 'index.md' &&
-            (r.version || versions.defaultVersion) === version &&
-            (!config.i18n ||
-              (r.locale || config.i18n.defaultLocale) === currentLocale),
-        )
-        if (versionIndexRoute) {
-          targetPath = versionIndexRoute.path
-        }
-      }
-    } else {
-      // Recovery mode: if currently on a 404, attempt to find ANY document in the target version
-      const fallbackRoute = allRoutes.find(
-        (r) =>
-          (r.version || versions.defaultVersion) === version &&
-          (!config.i18n ||
-            (r.locale || config.i18n.defaultLocale) === currentLocale),
-      )
-      if (fallbackRoute) {
-        targetPath = fallbackRoute.path
-      }
-    }
-
-    navigate(targetPath)
-  }
-
-  const currentVersionConfig = versions?.versions?.find?.(
-    (v) => v.path === currentVersion,
-  )
-  const currentVersionLabel = currentVersionConfig?.label || currentVersion
-
-  const availableVersions = useMemo(() => {
-    return versions
-      ? versions.versions.map((v) => ({
-          key: v.path as BoltdocsVersion,
-          label: v.label,
-          value: v.path,
-          isCurrent: v.path === currentVersion,
-        }))
-      : []
-  }, [versions, currentVersion])
-
-  return {
-    currentVersion,
-    currentVersionLabel,
-    availableVersions,
-    handleVersionChange,
-  }
-}

package/src/client/index.ts

@@ -1,31 +0,0 @@
-export type * from './types'
-export type {
-  BoltdocsLocale,
-  BoltdocsVersion,
-  BoltdocsTypes,
-} from '../shared/types'
-export * from './ssg'
-export { useConfig } from './app/config-context'
-export { useTheme } from './app/theme-context'
-export { useMdxComponents } from './app/mdx-components-context'
-export { useUI } from './app/ui-context'
-export * from './hooks/index'
-export { DocsLayout } from './components/docs-layout-default'
-export { Navbar } from './components/ui-base/navbar'
-export { Sidebar } from './components/ui-base/sidebar'
-export { OnThisPage } from './components/ui-base/on-this-page'
-export { Breadcrumbs } from './components/ui-base/breadcrumbs'
-export { PageNav } from './components/ui-base/page-nav'
-export { ErrorBoundary } from './components/ui-base/error-boundary'
-export { CopyMarkdown } from './components/ui-base/copy-markdown'
-export { SearchDialog } from './components/ui-base/search-dialog'
-export { NotFound } from './components/ui-base/not-found'
-export { Card } from './components/mdx/card'
-export { Cards } from './components/mdx/cards'
-
-// Utilities
-export { cn } from './utils/cn'
-export { getTranslated } from './utils/i18n'
-export { reactToText } from './utils/react-to-text'
-export { copyToClipboard } from './utils/copy-clipboard'
-export { getStarsRepo } from './utils/github'

package/src/client/mdx.ts

@@ -1,2 +0,0 @@
-import { mdx_components_default as Mdx } from './components/mdx'
-export default Mdx