@brillout/docpress 0.6.8 → 0.6.10

package/MobileHeader.tsx

@@ -28,7 +28,7 @@ function MobileHeader() {
           borderBottom: '1px solid #ddd',
         }}
       >
-        <MenuToggle />
+        <MobileShowNavigationToggle />
         <a
           href="/"
           style={{
@@ -47,9 +47,9 @@ function MobileHeader() {
   )
 }
 
-function MenuToggle() {
+function MobileShowNavigationToggle() {
   return (
-    <div style={{ padding: 20, lineHeight: 0, cursor: 'pointer' }} id="menu-toggle">
+    <div style={{ padding: 20, lineHeight: 0, cursor: 'pointer' }} id="mobile-show-navigation-toggle">
       <svg
         style={{ width: 20 }}
         className="icon"

package/PageLayout.tsx

@@ -17,7 +17,7 @@ function PageLayout({ pageContext, children }: { pageContext: PageContextResolve
       <PageContextProvider pageContext={pageContext}>
         <div id="page-layout" className={isLandingPage ? 'landing-page' : 'doc-page'}>
           <div id="navigation-wrapper">
-            <Navigation pageContext={pageContext} />
+            <Navigation {...pageContext.navigationData} />
           </div>
           <NavigationFullscreenButton />
           <div id="page-wrapper">

package/components/Link.tsx

@@ -1,12 +1,13 @@
 export { Link }
+export type { LinkData }
 
 import React from 'react'
 import { isRepoLink, RepoLink } from './RepoLink'
-import type { Heading, HeadingDetached } from '../types/Heading'
 import type { PageContextResolved } from '../config/resolvePageContext'
 import { usePageContext } from '../renderer/usePageContext'
 import { assert, assertUsage, determineSectionTitle, determineSectionUrlHash } from '../utils/server'
 import { parseTitle } from '../parseTitle'
+import pc from '@brillout/picocolors'
 
 function Link({
   href,
@@ -48,54 +49,27 @@ function getLinkText({
   pageContext: PageContextResolved
   doNotInferSectionTitle: true | undefined
 }): string | JSX.Element {
-  let urlHash: string | null = null
-  let hrefWithoutHash: string = href
-  if (href.includes('#')) {
-    ;[hrefWithoutHash, urlHash] = href.split('#')
-    assert(hrefWithoutHash || urlHash)
-  }
+  const { hrefPathname, hrefHash } = parseHref(href)
 
-  let heading: Heading | HeadingDetached
-  let isLinkOnSamePage: boolean = false
-  if (hrefWithoutHash) {
-    heading = findHeading(hrefWithoutHash, pageContext)
-    if (heading.url === pageContext.urlPathname) {
-      isLinkOnSamePage = true
-      // heading !== pageContext.activeHeading because activeHeading is a different object holding on-this-page subheadings
-      heading = pageContext.activeHeading
-    }
-  } else {
-    assert(urlHash)
-    isLinkOnSamePage = true
-    heading = pageContext.activeHeading
-  }
-  assert(heading)
-  assert(isLinkOnSamePage === (heading.url === pageContext.urlPathname))
-  assert(isLinkOnSamePage === (heading.url === pageContext.activeHeading.url))
-  assert(isLinkOnSamePage === (heading === pageContext.activeHeading))
+  const linkData = findLinkData(hrefPathname || pageContext.urlPathname, pageContext)
+  const isLinkOnSamePage = linkData.url === pageContext.urlPathname
+  if (!hrefPathname) assert(isLinkOnSamePage)
 
   const breadcrumbParts: (string | JSX.Element)[] = []
-
-  if (heading.headingsBreadcrumb) {
-    breadcrumbParts.push(
-      ...(heading.headingsBreadcrumb ?? [])
-        .slice()
-        .reverse()
-        .map(({ title }) => title),
-    )
+  if (linkData.linkBreadcrumb) {
+    breadcrumbParts.push(...(linkData.linkBreadcrumb ?? []).slice().reverse())
   }
+  breadcrumbParts.push(linkData.title)
 
-  breadcrumbParts.push(heading.title)
-
-  if (urlHash) {
+  if (hrefHash) {
     let sectionTitle: string | JSX.Element | undefined = undefined
-    assert(!urlHash.startsWith('#'))
+    assert(!hrefHash.startsWith('#'))
     if (isLinkOnSamePage) {
-      const pageHeading = findHeading(`#${urlHash}`, pageContext)
-      sectionTitle = pageHeading.title
-    } else if ('sectionTitles' in heading && heading.sectionTitles) {
-      heading.sectionTitles.forEach((title) => {
-        if (determineSectionUrlHash(title) === urlHash) {
+      const linkDataPageSection = findLinkData(`#${hrefHash}`, pageContext)
+      sectionTitle = linkDataPageSection.title
+    } else if ('sectionTitles' in linkData && linkData.sectionTitles) {
+      linkData.sectionTitles.forEach((title) => {
+        if (determineSectionUrlHash(title) === hrefHash) {
           sectionTitle = parseTitle(title)
         }
       })
@@ -131,14 +105,53 @@ function getLinkText({
   )
 }
 
-function findHeading(href: string, pageContext: PageContextResolved): Heading | HeadingDetached {
+type LinkData = {
+  url?: null | string
+  title: JSX.Element
+  linkBreadcrumb: null | JSX.Element[]
+  sectionTitles?: string[]
+}
+
+function findLinkData(href: string, pageContext: PageContextResolved): LinkData {
   assert(href.startsWith('/') || href.startsWith('#'))
-  const { headingsAll } = pageContext
-  const heading = headingsAll.find(({ url }) => href === url)
+  const { linksAll } = pageContext
+  const linkData = linksAll.find(({ url }) => href === url)
   if (href.startsWith('#')) {
-    assertUsage(heading, `Couldn't find ${href} in ${pageContext.urlPathname}, does it exist?`)
+    assertUsage(linkData, `Couldn't find ${href} in ${pageContext.urlPathname}, does it exist?`)
   } else {
-    assertUsage(heading, `Couldn't find heading for ${href}, did you define the heading for ${href}?`)
+    assertUsage(
+      linkData,
+      [
+        `Couldn't find page with URL ${pc.bold(href)}`,
+        `— did you define it in`,
+        [
+          pc.cyan('docpress.config.js'),
+          pc.dim('#{'),
+          pc.cyan('headings'),
+          pc.dim(','),
+          pc.cyan('headingsDetached'),
+          pc.dim('}'),
+          '?',
+        ].join(''),
+      ].join(' '),
+    )
+  }
+  return linkData
+}
+
+function parseHref(href: string) {
+  let hrefHash: string | null = null
+  let hrefPathname: string | null = null
+  if (!href.includes('#')) {
+    hrefPathname = href
+  } else {
+    const [partsFirst, ...partsRest] = href.split('#')
+    if (partsFirst) {
+      hrefPathname = partsFirst
+    }
+    hrefHash = partsRest.join('#')
   }
-  return heading
+  assert(hrefPathname !== null || hrefHash !== null)
+  assert(hrefPathname || hrefHash)
+  return { hrefPathname, hrefHash }
 }

package/config/resolveHeadingsData.ts

@@ -0,0 +1,291 @@
+export { resolveHeadingsData }
+
+import { assert, jsxToTextContent } from '../utils/server'
+import type {
+  HeadingDefinition,
+  HeadingDetachedDefinition,
+  HeadingResolved,
+  HeadingDetachedResolved,
+} from '../types/Heading'
+import type { Config } from '../types/Config'
+import { getConfig } from './getConfig'
+import { parseTitle, withEmoji } from '../parseTitle'
+import { NavigationData, NavItem } from '../navigation/Navigation'
+import type { LinkData } from '../components'
+import type { Exports, PageContextOriginal } from './resolvePageContext'
+import pc from '@brillout/picocolors'
+
+type PageSectionResolved = {
+  url: string | null
+  title: JSX.Element
+  titleInNav: JSX.Element
+  linkBreadcrumb: JSX.Element[]
+  pageSectionLevel: number
+}
+
+function resolveHeadingsData(pageContext: PageContextOriginal) {
+  const config = getConfig()
+
+  {
+    const { headings, headingsDetached } = config
+    assertHeadingsDefinition([...headings, ...headingsDetached])
+  }
+
+  const resolved = getHeadingsResolved(config)
+  const { headingsDetachedResolved } = resolved
+  let { headingsResolved } = resolved
+
+  const { activeHeading, isDetachedPage } = getActiveHeading(headingsResolved, headingsDetachedResolved, pageContext)
+
+  const { documentTitle, isLandingPage, pageTitle } = getTitles(activeHeading, pageContext, config)
+
+  const pageSectionsResolved = getPageSectionsResolved(pageContext, activeHeading)
+
+  const linksAll: LinkData[] = [
+    ...pageSectionsResolved.map(pageSectionToLinkData),
+    ...headingsResolved.map(headingToLinkData),
+    ...headingsDetachedResolved.map(headingToLinkData),
+  ]
+
+  let navigationData: NavigationData
+  {
+    const currentUrl: string = pageContext.urlPathname
+    const navItemsPageSections = pageSectionsResolved
+      .filter((pageSection) => pageSection.pageSectionLevel === 2)
+      .map(pageSectionToNavItem)
+    if (isDetachedPage) {
+      const navItemsAll: NavItem[] = headingsResolved
+      const navItems: NavItem[] = [headingToNavItem(activeHeading), ...navItemsPageSections]
+      navigationData = {
+        isDetachedPage: true,
+        navItems,
+        navItemsAll,
+        currentUrl,
+      }
+    } else {
+      const navItemsAll: NavItem[] = headingsResolved.map(headingToNavItem)
+      const activeHeadingIndex = navItemsAll.findIndex((navItem) => navItem.url === currentUrl)
+      assert(activeHeadingIndex >= 0)
+      navItemsPageSections.forEach((navItem, i) => {
+        navItemsAll.splice(activeHeadingIndex + 1 + i, 0, navItem)
+      })
+
+      navigationData = {
+        isDetachedPage: false,
+        navItems: navItemsAll,
+        navItemsAll,
+        currentUrl,
+      }
+    }
+  }
+
+  const pageContextAddendum = {
+    navigationData,
+    linksAll,
+    isLandingPage,
+    pageTitle,
+    documentTitle,
+  }
+  return pageContextAddendum
+}
+
+function headingToNavItem(heading: HeadingResolved | HeadingDetachedResolved): NavItem {
+  return {
+    level: heading.level,
+    url: heading.url,
+    title: heading.title,
+    titleInNav: heading.titleInNav,
+  }
+}
+function headingToLinkData(heading: HeadingResolved | HeadingDetachedResolved): LinkData {
+  return {
+    url: heading.url,
+    title: heading.title,
+    linkBreadcrumb: heading.linkBreadcrumb,
+    sectionTitles: heading.sectionTitles,
+  }
+}
+function pageSectionToNavItem(pageSection: PageSectionResolved): NavItem {
+  return {
+    level: pageSection.pageSectionLevel + 1,
+    url: pageSection.url,
+    title: pageSection.title,
+    titleInNav: pageSection.titleInNav,
+  }
+}
+function pageSectionToLinkData(pageSection: PageSectionResolved): LinkData {
+  return {
+    url: pageSection.url,
+    title: pageSection.title,
+    linkBreadcrumb: pageSection.linkBreadcrumb,
+  }
+}
+
+function getTitles(
+  activeHeading: HeadingResolved | HeadingDetachedResolved,
+  pageContext: { urlOriginal: string },
+  config: Config,
+) {
+  const url = pageContext.urlOriginal
+  const isLandingPage = url === '/'
+
+  const { title } = activeHeading
+  let pageTitle = isLandingPage ? null : title
+  let documentTitle = activeHeading.titleDocument || jsxToTextContent(title)
+
+  if (!isLandingPage) {
+    documentTitle += ' | ' + config.projectInfo.projectName
+  }
+
+  if (isLandingPage) {
+    pageTitle = null
+  }
+
+  return { documentTitle, isLandingPage, pageTitle }
+}
+
+function getActiveHeading(
+  headingsResolved: HeadingResolved[],
+  headingsDetachedResolved: HeadingDetachedResolved[],
+  pageContext: { urlOriginal: string; exports: Exports },
+) {
+  let activeHeading: HeadingResolved | HeadingDetachedResolved | null = null
+  const { urlOriginal } = pageContext
+  assert(urlOriginal)
+  headingsResolved.forEach((heading) => {
+    if (heading.url === urlOriginal) {
+      activeHeading = heading
+      assert(heading.level === 2, { pageUrl: urlOriginal, heading })
+    }
+  })
+  const isDetachedPage = !activeHeading
+  if (!activeHeading) {
+    activeHeading = headingsDetachedResolved.find(({ url }) => urlOriginal === url) ?? null
+  }
+  if (!activeHeading) {
+    throw new Error(
+      [
+        `URL ${pc.bold(urlOriginal)} not found in following URLs:`,
+        ...headingsResolved
+          .map((h) => `  ${h.url}`)
+          .filter(Boolean)
+          .sort(),
+      ].join('\n'),
+    )
+  }
+  return { activeHeading, isDetachedPage }
+}
+
+function getPageSectionsResolved(
+  pageContext: { exports: Exports; urlOriginal: string },
+  activeHeading: HeadingResolved | HeadingDetachedResolved,
+): PageSectionResolved[] {
+  const pageSections = pageContext.exports.pageSectionsExport ?? []
+
+  const pageSectionsResolved = pageSections.map((pageSection) => {
+    const pageSectionTitleJsx = parseTitle(pageSection.pageSectionTitle)
+    const url: null | string = pageSection.pageSectionId === null ? null : '#' + pageSection.pageSectionId
+    const pageSectionResolved: PageSectionResolved = {
+      url,
+      title: pageSectionTitleJsx,
+      linkBreadcrumb: [activeHeading.title, ...(activeHeading.linkBreadcrumb ?? [])],
+      titleInNav: pageSectionTitleJsx,
+      pageSectionLevel: pageSection.pageSectionLevel,
+    }
+    return pageSectionResolved
+  })
+
+  if (activeHeading?.sectionTitles) {
+    activeHeading.sectionTitles.forEach((sectionTitle) => {
+      const pageSectionTitles = pageSections.map((h) => h.pageSectionTitle)
+      assert(pageSectionTitles.includes(sectionTitle), { pageHeadingTitles: pageSectionTitles, sectionTitle })
+    })
+  }
+
+  return pageSectionsResolved
+}
+
+/**
+ * - Parse title (from `string` to `JSX.Element`)
+ * - Determine navigation breadcrumbs
+ */
+function getHeadingsResolved(config: {
+  headings: HeadingDefinition[]
+  headingsDetached: HeadingDetachedDefinition[]
+}): {
+  headingsResolved: HeadingResolved[]
+  headingsDetachedResolved: HeadingDetachedResolved[]
+} {
+  const headingsWithoutBreadcrumb: Omit<HeadingResolved, 'linkBreadcrumb'>[] = config.headings.map(
+    (heading: HeadingDefinition) => {
+      const titleParsed: JSX.Element = parseTitle(heading.title)
+
+      const titleInNav = heading.titleInNav || heading.title
+      let titleInNavParsed: JSX.Element
+      titleInNavParsed = parseTitle(titleInNav)
+      if ('titleEmoji' in heading) {
+        assert(heading.titleEmoji)
+        titleInNavParsed = withEmoji(heading.titleEmoji, titleInNavParsed)
+      }
+
+      const headingResolved: Omit<HeadingResolved, 'linkBreadcrumb'> = {
+        ...heading,
+        title: titleParsed,
+        titleInNav: titleInNavParsed,
+      }
+      return headingResolved
+    },
+  )
+
+  const headingsResolved: HeadingResolved[] = []
+  headingsWithoutBreadcrumb.forEach((heading) => {
+    const linkBreadcrumb = getHeadingsBreadcrumb(heading, headingsResolved)
+    headingsResolved.push({
+      ...heading,
+      linkBreadcrumb,
+    })
+  })
+
+  const headingsDetachedResolved = config.headingsDetached.map((headingsDetached) => {
+    const { url, title } = headingsDetached
+    assert(
+      headingsResolved.find((heading) => heading.url === url) === undefined,
+      `remove ${headingsDetached.url} from headingsDetached`,
+    )
+    const titleParsed = typeof title === 'string' ? parseTitle(title) : title
+    return {
+      ...headingsDetached,
+      level: 2 as const,
+      title: titleParsed,
+      titleInNav: titleParsed,
+      linkBreadcrumb: null,
+    }
+  })
+
+  return { headingsResolved, headingsDetachedResolved }
+}
+
+function getHeadingsBreadcrumb(heading: Omit<HeadingResolved, 'linkBreadcrumb'>, headings: HeadingResolved[]) {
+  const linkBreadcrumb: JSX.Element[] = []
+  let levelCurrent = heading.level
+  headings
+    .slice()
+    .reverse()
+    .forEach((parentCandidate) => {
+      const isParent = parentCandidate.level < levelCurrent
+      if (isParent) {
+        levelCurrent = parentCandidate.level
+        linkBreadcrumb.push(parentCandidate.title)
+      }
+    })
+  return linkBreadcrumb
+}
+
+function assertHeadingsDefinition(headings: { url?: null | string }[]) {
+  headings.forEach((heading) => {
+    if (heading.url) {
+      const { url } = heading
+      assert(url.startsWith('/'))
+    }
+  })
+}

package/config/resolvePageContext.ts

@@ -1,56 +1,34 @@
-import { assert, jsxToTextContent, objectAssign } from '../utils/server'
-import type { Heading, HeadingDetached } from '../types/Heading'
-import type { PageContextBuiltInServer } from 'vike/types'
-import type { MarkdownHeading } from '../markdownHeadingsVitePlugin'
-import type { Config } from '../types/Config'
-import { getConfig } from './getConfig'
-import { getHeadingsWithProcessedTitle, parseTitle } from '../parseTitle'
-
 export { resolvePageContext }
 export type { PageContextOriginal }
 export type { PageContextResolved }
-export type { Heading }
+export type { Exports }
+
+import { objectAssign } from '../utils/server'
+import type { PageContextServer } from 'vike/types'
+import type { PageSection } from '../parsePageSections'
+import { getConfig } from './getConfig'
+import { resolveHeadingsData } from './resolveHeadingsData'
 
 type ReactComponent = () => JSX.Element
 type Exports = {
-  headings?: MarkdownHeading[]
+  pageSectionsExport?: PageSection[]
 }
-type PageContextOriginal = PageContextBuiltInServer & {
+type PageContextOriginal = PageContextServer & {
   Page: ReactComponent
   exports: Exports
 }
 type PageContextResolved = ReturnType<typeof resolvePageContext>
 
 function resolvePageContext(pageContext: PageContextOriginal) {
+  const pageContextResolved = {}
+
+  objectAssign(pageContextResolved, resolveHeadingsData(pageContext))
+
   const config = getConfig()
-  const processed = getHeadingsWithProcessedTitle(config)
-  const { headingsDetachedProcessed } = processed
-  let { headingsProcessed } = processed
-  const { activeHeading, activeNavigationHeading } = findHeading(
-    headingsProcessed,
-    headingsDetachedProcessed,
-    pageContext,
-  )
-  let headingsOfDetachedPage: null | (Heading | HeadingDetached)[] = null
-  let headingsAll = [...headingsProcessed, ...headingsDetachedProcessed]
-  headingsAll = getHeadingsAll(headingsAll, pageContext, activeHeading)
-  if (activeNavigationHeading) {
-    headingsProcessed = getHeadingsAll(headingsProcessed, pageContext, activeNavigationHeading)
-  } else {
-    headingsOfDetachedPage = [activeHeading, ...getHeadingsOfTheCurrentPage(pageContext, activeHeading)]
-  }
-  const { title, isLandingPage, pageTitle } = getMetaData(
-    headingsDetachedProcessed,
-    activeNavigationHeading,
-    pageContext,
-    config,
-  )
   const { faviconUrl, algolia, tagline, twitterHandle, bannerUrl, websiteUrl } = config
-  const pageContextResolved = {}
   objectAssign(pageContextResolved, {
     ...pageContext,
     meta: {
-      title,
       faviconUrl,
       twitterHandle,
       bannerUrl,
@@ -58,129 +36,8 @@ function resolvePageContext(pageContext: PageContextOriginal) {
       tagline,
       algolia,
     },
-    activeHeading,
-    headingsAll,
-    headingsProcessed,
-    headingsDetachedProcessed,
-    headingsOfDetachedPage,
-    isLandingPage,
-    pageTitle,
     config,
   })
-  return pageContextResolved
-}
-
-function getMetaData(
-  headingsDetachedProcessed: HeadingDetached[],
-  activeNavigationHeading: Heading | null,
-  pageContext: { urlOriginal: string; exports: Exports },
-  config: Config,
-) {
-  const url = pageContext.urlOriginal
-
-  let title: string
-  let pageTitle: string | JSX.Element | null
-  if (activeNavigationHeading) {
-    title = activeNavigationHeading.titleDocument || jsxToTextContent(activeNavigationHeading.title)
-    pageTitle = activeNavigationHeading.title
-  } else {
-    pageTitle = headingsDetachedProcessed.find((h) => h.url === url)!.title
-    title = jsxToTextContent(pageTitle)
-  }
-
-  const isLandingPage = url === '/'
-  if (!isLandingPage) {
-    title += ' | ' + config.projectInfo.projectName
-  }
-
-  if (isLandingPage) {
-    pageTitle = null
-  }
-
-  return { title, isLandingPage, pageTitle }
-}
-
-function findHeading(
-  headingsProcessed: Heading[],
-  headingsDetachedProcessed: HeadingDetached[],
-  pageContext: { urlOriginal: string; exports: Exports },
-): { activeHeading: Heading | HeadingDetached; activeNavigationHeading: Heading | null } {
-  let activeNavigationHeading: Heading | null = null
-  let activeHeading: Heading | HeadingDetached | null = null
-  assert(pageContext.urlOriginal)
-  const pageUrl = pageContext.urlOriginal
-  headingsProcessed.forEach((heading) => {
-    if (heading.url === pageUrl) {
-      activeNavigationHeading = heading
-      activeHeading = heading
-      assert(heading.level === 2, { pageUrl, heading })
-    }
-  })
-  if (!activeHeading) {
-    activeHeading = headingsDetachedProcessed.find(({ url }) => pageUrl === url) ?? null
-  }
-  if (!activeHeading) {
-    throw new Error(
-      [
-        `Heading not found for URL '${pageUrl}'`,
-        'Heading is defined for following URLs:',
-        ...headingsProcessed
-          .map((h) => `  ${h.url}`)
-          .filter(Boolean)
-          .sort(),
-      ].join('\n'),
-    )
-  }
-  return { activeHeading, activeNavigationHeading }
-}
-
-function getHeadingsAll<T extends Heading | HeadingDetached>(
-  headingsProcessed: T[],
-  pageContext: { exports: Exports; urlOriginal: string },
-  activeHeading: T,
-): T[] {
-  const headingsAll = headingsProcessed.slice()
-
-  const headingsOfTheCurrentPage = getHeadingsOfTheCurrentPage(pageContext, activeHeading)
-
-  const activeHeadingIdx = headingsAll.indexOf(activeHeading)
-  assert(activeHeadingIdx >= 0)
-  headingsOfTheCurrentPage.forEach((pageHeading, i) => {
-    headingsAll.splice(activeHeadingIdx + 1 + i, 0, pageHeading as T)
-  })
 
-  return headingsAll
-}
-
-function getHeadingsOfTheCurrentPage(
-  pageContext: { exports: Exports; urlOriginal: string },
-  currentHeading: Heading | HeadingDetached,
-) {
-  const headingsOfCurrentPage: Heading[] = []
-
-  const headingsExport = pageContext.exports.headings ?? []
-
-  headingsExport.forEach((markdownHeading) => {
-    const title = parseTitle(markdownHeading.title)
-    const url: null | string = markdownHeading.headingId && '#' + markdownHeading.headingId
-    if (markdownHeading.headingLevel === 2) {
-      const heading: Heading = {
-        url,
-        title,
-        headingsBreadcrumb: [currentHeading, ...(currentHeading.headingsBreadcrumb ?? [])],
-        titleInNav: title,
-        level: 3,
-      }
-      headingsOfCurrentPage.push(heading)
-    }
-  })
-
-  if (currentHeading?.sectionTitles) {
-    currentHeading.sectionTitles.forEach((sectionTitle) => {
-      const pageHeadingTitles = headingsExport.map((h) => h.title)
-      assert(pageHeadingTitles.includes(sectionTitle), { pageHeadingTitles, sectionTitle })
-    })
-  }
-
-  return headingsOfCurrentPage
+  return pageContextResolved
 }

package/dist/+config.js

@@ -5,11 +5,11 @@ export default {
     client: 'import:@brillout/docpress/renderer/client:doesNotExist',
     meta: {
         Page: {
-            env: { client: false, server: true }
+            env: { client: false, server: true },
         },
         // Vike already defines the setting 'name', but we redundantly define it here for older Vike versions (otherwise older Vike versions will complain that 'name` is an unknown config).
         name: {
-            env: { config: true }
-        }
-    }
+            env: { config: true },
+        },
+    },
 };

package/dist/parsePageSections.d.ts

@@ -0,0 +1,12 @@
+export { parsePageSections };
+export type { PageSection };
+type PageSection = {
+    pageSectionTitle: string;
+    pageSectionId: string | null;
+    pageSectionLevel: number;
+};
+declare function parsePageSections(): {
+    name: string;
+    enforce: string;
+    transform: (code: string, id: string) => Promise<string | undefined>;
+};