BaseHub Integration

Copyexport interface ParseTOCOptions {
  node: RichTextTocNode | RichTextTocNode[];
  /** @default 0 */
  initialLevel?: number;
 
  /** render rich text node */
  render: (node: RichTextNode) => ReactNode;
}

Copyexport function parseToc(options: ParseTOCOptions): TOCItemType[] {
  const { node: root, render, initialLevel = 0 } = options;
  const results: TOCItemType[] = [];
 
  function next(node: RichTextTocNode, level = initialLevel) {
    if (node.type === 'text' || !node.content) return;
 
    for (const item of node.content) {
      if (item.type === 'orderedList' || item.type === 'listItem') {
        next(item, level + 1);
        continue;
      }
 
      if (item.type !== 'paragraph' || !item.content || item.content.length === 0) continue;
 
      for (const text of findTextNode(item.content[0])) {
        const mark = text.marks?.find((m) => m.type === 'link');
        if (!mark) continue;
 
        results.push({
          depth: level + 1,
          url: mark.attrs.href,
          title: render({
            ...text,
            marks: text.marks?.filter((m) => m.type !== 'link'),
          } as RichTextNode),
        });
      }
    }
  }
 
  if (Array.isArray(root)) for (const item of root) next(item);
  else next(root);
 
  return results;
}

Copyfunction findTextNode(n: RichTextTocNode): Extract<RichTextTocNode, { type: 'text' }>[] {
  if (n.type === 'text') {
    return [n];
  }
 
  return n.content?.flatMap(findTextNode) ?? [];
}

Copyfunction findTextNode(n: RichTextTocNode): Extract<RichTextTocNode, { type: 'text' }>[] {
  if (n.type === 'text') {
    return [n];
  }
 
  return n.content?.flatMap(findTextNode) ?? [];
}

Copyfunction next(node: RichTextTocNode, level = initialLevel) {
  if (node.type === 'text' || !node.content) return;
 
  for (const item of node.content) {
    if (item.type === 'orderedList' || item.type === 'listItem') {
      next(item, level + 1);
      continue;
    }
 
    if (item.type !== 'paragraph' || !item.content || item.content.length === 0) continue;
 

Copyexport function toFumadocsSource<
  Mdx extends MDXStoreData<PageData> | MDXStoreLazyData<PageData, unknown> = MDXStoreData<
    PageData,
    unknown
  >,
  Meta extends { data: MetaData } = { data: MetaData },
>(mdxStore?: FileCollectionStore<Mdx>, metaStore?: FileCollectionStore<Meta>) {
  const out: StaticSource<{
    pageData: ToPageData<Mdx>;
    metaData: Meta['data'];
  }> = { files: [] };
  for (const page of mdxStore?.list() ?? []) {
    out.files.push({
      type: 'page',
      data: ('compiled' in page
        ? { ...page, ...page.compiled.frontmatter }
        : { ...page, ...page.frontmatter }) as unknown as ToPageData<Mdx>,
      path: page.path,
      absolutePath: page.fullPath,
    });
  }
  for (const file of metaStore?.list() ?? []) {
    out.files.push({
      type: 'meta',
      data: file.data,
      path: file.path,
      absolutePath: file.fullPath,
    });
  }
  return out;
}

Copyexport function createSanitySource<Doc extends BaseDoc>(
  options: SanityOptions<Doc>,
): DynamicSource<{
  pageData: DocToPage<Doc>;
  metaData: MetaData;
}> {
  const { docType, baseDir, generatePath } = options;
  let sanityFetch: <R = unknown>(query: string, params?: QueryParams) => Promise<R>;
 
  if ('sanityFetch' in options) {
    const fn = options.sanityFetch;
    sanityFetch = async (query, params) => {
      const res = await fn({ query, params });
      return res.data as never;
    };
  } else {
    const client = options.client;
    sanityFetch = client.fetch.bind(client);
  }
 
  return {
    async files() {
      const data = await sanityFetch<ShallowDoc<Doc>[]>(
        `*[_type == $docType]{ _id, _type, title, slug, description }`,
        {
          docType,
        },
      );
 
      return data.map((file) => {
        const slugs = file.slug?.current?.split('/').filter((v) => v.length > 0) ?? [];
        let filePath = generatePath
          ? generatePath(file)
          : slugs.length === 0
            ? 'index.mdx'
            : `${slugs.join('/')}.mdx`;
        if (baseDir) filePath = path.join(baseDir, filePath);
 
        return {
          type: 'page',
          data: {
            ...file,
            title: file.title ?? file._id,
            async load() {
              const data = await sanityFetch<Doc & { _toc?: PortableTextBlock[] }>(
                `*[_type == $docType && _id == $id][0]{
                  ...,
                  "_toc": body[style in ["h1", "h2", "h3", "h4", "h5", "h6"]]
                }`,
                {
                  id: file._id,
                  docType,
                },
              );
 
              return {
                ...data,
                _toc: data._toc ?? [],
                renderToc(opts) {
                  if (!data._toc) return [];
                  return renderToc({ toc: data._toc, ...opts });
                },
              };
            },
            async structuredData() {
              const data = await sanityFetch<{ structuredBody: StructuredBlock[] } | undefined>(
                `*[_type == $docType && _id == $id][0]{
                  "structuredBody": body[]{
                    ...,
                    _type == "block" => {
                      "heading": select(
                        style == "h1" => "h1",
                        style == "h2" => "h2",
                        style == "h3" => "h3",
                        style == "h4" => "h4",
                        style == "h5" => "h5",
                        style == "h6" => "h6",
                        null
                      ),
                      "content": pt::text(@)

Copyexport function useFooterItems(): PageTree.Item[] {
  const { root } = useTreeContext();
  const cached = footerCache.get(root);
  if (cached) return cached;
 
  const list: PageTree.Item[] = [];
  function onNode(node: PageTree.Node) {
    if (node.type === 'folder') {
      if (node.index) onNode(node.index);
      for (const child of node.children) onNode(child);
    } else if (node.type === 'page' && !node.external) {
      list.push(node);
    }
  }
 
  for (const child of root.children) onNode(child);
  footerCache.set(root, list);
  return list;

Copyasync docs(): Promise<DocsLayoutProps> {
  const config = await getConfigRuntime();
  const source = await getSource(config);
  return {
    tree: source.getPageTree(),
    ...(await this.base()),
  };
},