fumadocs-core 8.0.0

package/dist/search/server.js

@@ -0,0 +1,209 @@
+import {
+  __spreadProps,
+  __spreadValues
+} from "../chunk-WEAGW6MQ.js";
+
+// src/search/server.ts
+import { Document } from "flexsearch";
+import nextLib from "next/server";
+function createSearchAPI(type, options) {
+  if (type === "simple") {
+    return initSearchAPI(options);
+  }
+  return initSearchAPIAdvanced(options);
+}
+function createI18nSearchAPI(type, options) {
+  const map = /* @__PURE__ */ new Map();
+  for (const [k, v] of options.indexes) {
+    map.set(
+      k,
+      createSearchAPI(type, __spreadProps(__spreadValues({}, options), {
+        language: k,
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-assignment -- Avoid complicated types
+        indexes: v
+      }))
+    );
+  }
+  return {
+    GET(request) {
+      const locale = request.nextUrl.searchParams.get("locale");
+      if (locale) {
+        const handler = map.get(locale);
+        if (handler)
+          return handler.GET(request);
+      }
+      return nextLib.NextResponse.json([]);
+    }
+  };
+}
+function initSearchAPI({ indexes, language }) {
+  const store = ["title", "url"];
+  const index = new Document({
+    language,
+    optimize: true,
+    cache: 100,
+    document: {
+      id: "url",
+      store,
+      index: [
+        {
+          field: "title",
+          tokenize: "forward",
+          resolution: 9
+        },
+        {
+          field: "content",
+          tokenize: "strict",
+          context: {
+            depth: 1,
+            resolution: 9
+          }
+        },
+        {
+          field: "keywords",
+          tokenize: "strict",
+          resolution: 9
+        }
+      ]
+    }
+  });
+  for (const page of indexes) {
+    index.add({
+      title: page.title,
+      url: page.url,
+      content: page.content,
+      keywords: page.keywords
+    });
+  }
+  return {
+    GET(request) {
+      const { searchParams } = request.nextUrl;
+      const query = searchParams.get("query");
+      if (!query)
+        return nextLib.NextResponse.json([]);
+      const results = index.search(query, 5, {
+        enrich: true,
+        suggest: true
+      });
+      if (results.length === 0)
+        return nextLib.NextResponse.json([]);
+      const pages = results[0].result.map((page) => ({
+        type: "page",
+        content: page.doc.title,
+        id: page.doc.url,
+        url: page.doc.url
+      }));
+      return nextLib.NextResponse.json(pages);
+    }
+  };
+}
+function initSearchAPIAdvanced({
+  indexes,
+  language,
+  tag = false
+}) {
+  const store = ["id", "url", "content", "page_id", "type"];
+  const index = new Document({
+    language,
+    cache: 100,
+    tokenize: "forward",
+    optimize: true,
+    context: {
+      depth: 2,
+      bidirectional: true,
+      resolution: 9
+    },
+    document: {
+      id: "id",
+      tag: tag ? "tag" : void 0,
+      store,
+      index: ["content"]
+    }
+  });
+  for (const page of indexes) {
+    const data = page.structuredData;
+    let id = 0;
+    index.add({
+      id: page.id,
+      page_id: page.id,
+      type: "page",
+      content: page.title,
+      tag: page.tag,
+      url: page.url
+    });
+    for (const heading of data.headings) {
+      index.add({
+        id: page.id + id++,
+        page_id: page.id,
+        type: "heading",
+        tag: page.tag,
+        url: `${page.url}#${heading.id}`,
+        content: heading.content
+      });
+    }
+    for (const content of data.contents) {
+      index.add({
+        id: page.id + id++,
+        page_id: page.id,
+        tag: page.tag,
+        type: "text",
+        url: content.heading ? `${page.url}#${content.heading}` : page.url,
+        content: content.content
+      });
+    }
+  }
+  return {
+    GET(request) {
+      var _a, _b, _c;
+      const query = request.nextUrl.searchParams.get("query");
+      const paramTag = request.nextUrl.searchParams.get("tag");
+      if (!query)
+        return nextLib.NextResponse.json([]);
+      const results = index.search(query, 5, {
+        enrich: true,
+        tag: paramTag != null ? paramTag : void 0,
+        limit: 6
+      });
+      const map = /* @__PURE__ */ new Map();
+      const sortedResult = [];
+      for (const item of (_b = (_a = results[0]) == null ? void 0 : _a.result) != null ? _b : []) {
+        if (item.doc.type === "page") {
+          if (!map.has(item.doc.page_id)) {
+            map.set(item.doc.page_id, []);
+          }
+          continue;
+        }
+        const i = {
+          id: item.doc.id,
+          content: item.doc.content,
+          type: item.doc.type,
+          url: item.doc.url
+        };
+        if (map.has(item.doc.page_id)) {
+          (_c = map.get(item.doc.page_id)) == null ? void 0 : _c.push(i);
+        } else {
+          map.set(item.doc.page_id, [i]);
+        }
+      }
+      for (const [id, items] of map.entries()) {
+        const page = index.get(id);
+        if (!page)
+          continue;
+        sortedResult.push({
+          id: page.id,
+          content: page.content,
+          type: "page",
+          url: page.url
+        });
+        sortedResult.push(...items);
+      }
+      return nextLib.NextResponse.json(sortedResult);
+    }
+  };
+}
+export {
+  createI18nSearchAPI,
+  createSearchAPI,
+  initSearchAPI,
+  initSearchAPIAdvanced
+};

package/dist/search/shared.d.ts

@@ -0,0 +1,8 @@
+interface SortedResult {
+    id: string;
+    url: string;
+    type: 'page' | 'heading' | 'text';
+    content: string;
+}
+
+export type { SortedResult };

package/dist/search-algolia/client.d.ts

@@ -0,0 +1,28 @@
+import { SearchOptions, Hit } from '@algolia/client-search';
+import { SearchIndex } from 'algoliasearch/lite';
+import { SWRResponse } from 'swr';
+import { SortedResult } from '../search/shared.js';
+import { BaseIndex } from './server.js';
+import 'algoliasearch';
+import '../remark-structure-RwYPDA6M.js';
+import 'mdast';
+import 'unified';
+
+interface Options extends SearchOptions {
+    /**
+     * Use `empty` as result if query is empty
+     */
+    allowEmpty?: boolean;
+}
+declare function groupResults(hits: Hit<BaseIndex>[]): SortedResult[];
+declare function searchDocs(index: SearchIndex, query: string, options?: SearchOptions): Promise<SortedResult[]>;
+interface UseAlgoliaSearch {
+    search: string;
+    setSearch: (v: string) => void;
+    query: SWRResponse<SortedResult[] | 'empty', Error, {
+        keepPreviousData: true;
+    }>;
+}
+declare function useAlgoliaSearch(index: SearchIndex, { allowEmpty, ...options }?: Options): UseAlgoliaSearch;
+
+export { type Options, groupResults, searchDocs, useAlgoliaSearch };

package/dist/search-algolia/client.js

@@ -0,0 +1,68 @@
+import {
+  __async,
+  __objRest,
+  __spreadValues
+} from "../chunk-WEAGW6MQ.js";
+
+// src/search-algolia/client.ts
+import { useState } from "react";
+import useSWR from "swr";
+function groupResults(hits) {
+  const grouped = [];
+  const scannedUrls = /* @__PURE__ */ new Set();
+  for (const hit of hits) {
+    if (!scannedUrls.has(hit.url)) {
+      scannedUrls.add(hit.url);
+      grouped.push({
+        id: hit.url,
+        type: "page",
+        url: hit.url,
+        content: hit.title
+      });
+    }
+    grouped.push({
+      id: hit.objectID,
+      type: hit.content === hit.section ? "heading" : "text",
+      url: hit.section_id ? `${hit.url}#${hit.section_id}` : hit.url,
+      content: hit.content
+    });
+  }
+  return grouped;
+}
+function searchDocs(index, query, options) {
+  return __async(this, null, function* () {
+    if (query.length === 0) {
+      const result2 = yield index.search(query, __spreadValues({
+        distinct: 1,
+        hitsPerPage: 8
+      }, options));
+      return groupResults(result2.hits).filter((hit) => hit.type === "page");
+    }
+    const result = yield index.search(query, __spreadValues({
+      distinct: 5,
+      hitsPerPage: 10
+    }, options));
+    return groupResults(result.hits);
+  });
+}
+function useAlgoliaSearch(index, _a = {}) {
+  var _b = _a, { allowEmpty = true } = _b, options = __objRest(_b, ["allowEmpty"]);
+  const [search, setSearch] = useState("");
+  const query = useSWR(
+    ["/api/search", search, allowEmpty, options],
+    () => __async(this, null, function* () {
+      if (allowEmpty && search.length === 0)
+        return "empty";
+      return searchDocs(index, search, options);
+    }),
+    {
+      keepPreviousData: true
+    }
+  );
+  return { search, setSearch, query };
+}
+export {
+  groupResults,
+  searchDocs,
+  useAlgoliaSearch
+};

package/dist/search-algolia/server.d.ts

@@ -0,0 +1,45 @@
+import { SearchClient, SearchIndex } from 'algoliasearch';
+import { S as StructuredData } from '../remark-structure-RwYPDA6M.js';
+import 'mdast';
+import 'unified';
+
+interface DocumentRecord {
+    /**
+     * The ID of document, must be unique
+     */
+    _id: string;
+    title: string;
+    /**
+     * URL to the page
+     */
+    url: string;
+    structured: StructuredData;
+    /**
+     * Data to be added to each section index
+     */
+    extra_data?: object;
+}
+interface SyncOptions {
+    document?: string;
+    documents: DocumentRecord[];
+}
+declare function sync(client: SearchClient, { document, documents }: SyncOptions): Promise<void>;
+declare function setIndexSettings(index: SearchIndex): Promise<void>;
+declare function updateDocuments(index: SearchIndex, documents: DocumentRecord[]): Promise<void>;
+interface BaseIndex {
+    objectID: string;
+    title: string;
+    url: string;
+    section?: string;
+    /**
+     * The anchor id
+     */
+    section_id?: string;
+    /**
+     * The id of page, used for distinct
+     */
+    page_id: string;
+    content: string;
+}
+
+export { type BaseIndex, setIndexSettings, sync, updateDocuments };

package/dist/search-algolia/server.js

@@ -0,0 +1,68 @@
+import {
+  __async,
+  __spreadValues
+} from "../chunk-WEAGW6MQ.js";
+
+// src/search-algolia/server.ts
+import { randomUUID } from "crypto";
+function sync(_0, _1) {
+  return __async(this, arguments, function* (client, { document = "document", documents }) {
+    const index = client.initIndex(document);
+    yield setIndexSettings(index);
+    yield updateDocuments(index, documents);
+  });
+}
+function setIndexSettings(index) {
+  return __async(this, null, function* () {
+    yield index.setSettings({
+      attributeForDistinct: "page_id",
+      attributesToRetrieve: ["title", "section", "content", "url", "section_id"],
+      searchableAttributes: ["title", "section", "content"],
+      attributesToSnippet: [],
+      attributesForFaceting: ["tag"]
+    });
+  });
+}
+function getSections(page) {
+  const scannedHeadings = /* @__PURE__ */ new Set();
+  return page.structured.contents.flatMap((p) => {
+    const heading = p.heading ? page.structured.headings.find((h) => p.heading === h.id) : null;
+    const section = {
+      section: heading == null ? void 0 : heading.content,
+      section_id: heading == null ? void 0 : heading.id,
+      content: p.content
+    };
+    if (heading && !scannedHeadings.has(heading.id)) {
+      scannedHeadings.add(heading.id);
+      return [
+        {
+          section: heading.content,
+          section_id: heading.id,
+          content: heading.content
+        },
+        section
+      ];
+    }
+    return section;
+  });
+}
+function updateDocuments(index, documents) {
+  return __async(this, null, function* () {
+    const objects = documents.flatMap((page) => {
+      return getSections(page).map(
+        (section) => __spreadValues(__spreadValues({
+          objectID: `${page._id}-${randomUUID()}`,
+          title: page.title,
+          url: page.url,
+          page_id: page._id
+        }, section), page.extra_data)
+      );
+    });
+    yield index.replaceAllObjects(objects);
+  });
+}
+export {
+  setIndexSettings,
+  sync,
+  updateDocuments
+};

package/dist/server/index.d.ts

@@ -0,0 +1,57 @@
+import { T as TableOfContents } from '../get-toc-YF_TdazL.js';
+export { a as TOCItemType, g as getTableOfContents } from '../get-toc-YF_TdazL.js';
+import { N as Node, I as Item, R as Root } from '../page-tree-izSPERQk.js';
+export { p as PageTree } from '../page-tree-izSPERQk.js';
+import 'react';
+
+/**
+ * Parse TOC from portable text (Sanity)
+ *
+ * @param value - Blocks
+ * @param slugFn - A function that generates slug from title
+ */
+declare function getTableOfContentsFromPortableText(value: any): TableOfContents;
+
+/**
+ * Flatten tree to an array of page nodes
+ */
+declare function flattenTree(tree: Node[]): Item[];
+/**
+ * Get neighbours of a page, useful for implementing "previous & next" buttons
+ */
+declare function findNeighbour(tree: Root, url: string): {
+    previous?: Item;
+    next?: Item;
+};
+/**
+ * Separate the folder nodes of a root into multiple roots
+ */
+declare function separatePageTree(pageTree: Root): Root[];
+
+interface GetGithubLastCommitOptions {
+    /**
+     * Repository name, like "next-docs"
+     */
+    repo: string;
+    /** Owner of repository */
+    owner: string;
+    /**
+     * Path to file
+     */
+    path: string;
+    /**
+     * Github access token
+     */
+    token?: string;
+    /**
+     * Custom query parameters
+     */
+    params?: Record<string, string>;
+    options?: RequestInit;
+}
+/**
+ * Get the last edit time of a file
+ */
+declare function getGithubLastEdit({ repo, token, owner, path, options, params: customParams, }: GetGithubLastCommitOptions): Promise<Date | null>;
+
+export { type GetGithubLastCommitOptions, TableOfContents, findNeighbour, flattenTree, getGithubLastEdit, getTableOfContentsFromPortableText, separatePageTree };

package/dist/server/index.js

@@ -0,0 +1,148 @@
+import {
+  remarkHeading
+} from "../chunk-GT3Y35O6.js";
+import {
+  __async
+} from "../chunk-WEAGW6MQ.js";
+
+// src/server/get-toc.ts
+import { remark } from "remark";
+function getTableOfContents(content) {
+  return __async(this, null, function* () {
+    const result = yield remark().use(remarkHeading).process(content);
+    if ("toc" in result.data)
+      return result.data.toc;
+    return [];
+  });
+}
+
+// src/server/get-toc-sanity.ts
+import Slugger from "github-slugger";
+var slugger = new Slugger();
+function getTableOfContentsFromPortableText(value) {
+  if (!Array.isArray(value)) {
+    throw new Error("Invalid body type");
+  }
+  slugger.reset();
+  const result = [];
+  for (const block of value) {
+    dfs(block, result);
+  }
+  return result;
+}
+function dfs(block, list) {
+  var _a;
+  if (block.style && block.style.length === 2 && block.style.startsWith("h")) {
+    const depth = Number(block.style[1]);
+    if (Number.isNaN(depth))
+      return;
+    const text = flattenNode(block);
+    list.push({
+      title: text,
+      url: slugger.slug(text),
+      depth
+    });
+    return;
+  }
+  (_a = block.children) == null ? void 0 : _a.forEach((child) => {
+    dfs(child, list);
+  });
+}
+function flattenNode(block) {
+  var _a, _b;
+  let text = "";
+  if (block._type === "span") {
+    return (_a = block.text) != null ? _a : "";
+  }
+  (_b = block.children) == null ? void 0 : _b.forEach((child) => {
+    text += flattenNode(child);
+  });
+  return text;
+}
+
+// src/server/page-tree-utils.ts
+function flattenTree(tree) {
+  return tree.flatMap((node) => {
+    if (node.type === "separator")
+      return [];
+    if (node.type === "folder") {
+      const child = flattenTree(node.children);
+      if (node.index)
+        return [node.index, ...child];
+      return child;
+    }
+    return [node];
+  });
+}
+function findNeighbour(tree, url) {
+  const list = flattenTree(tree.children);
+  for (let i = 0; i < list.length; i++) {
+    if (list[i].url === url) {
+      return {
+        next: list[i + 1],
+        previous: list[i - 1]
+      };
+    }
+  }
+  return {};
+}
+function separatePageTree(pageTree) {
+  return pageTree.children.flatMap((child) => {
+    var _a;
+    if (child.type !== "folder")
+      return [];
+    return {
+      name: child.name,
+      url: (_a = child.index) == null ? void 0 : _a.url,
+      children: child.children
+    };
+  });
+}
+
+// src/server/page-tree.ts
+var page_tree_exports = {};
+
+// src/server/git-api.ts
+function getGithubLastEdit(_0) {
+  return __async(this, arguments, function* ({
+    repo,
+    token,
+    owner,
+    path,
+    options = {},
+    params: customParams = {}
+  }) {
+    const params = new URLSearchParams();
+    params.set("path", path);
+    params.set("page", "1");
+    params.set("per_page", "1");
+    for (const [key, value] of Object.entries(customParams)) {
+      params.set(key, value);
+    }
+    if (token) {
+      options.headers = new Headers(options.headers);
+      options.headers.append("authorization", token);
+    }
+    const res = yield fetch(
+      `https://api.github.com/repos/${owner}/${repo}/commits?${params.toString()}`,
+      options
+    );
+    if (!res.ok)
+      throw new Error(
+        `Failed to fetch last edit time from Git ${yield res.text()}`
+      );
+    const data = yield res.json();
+    if (data.length === 0)
+      return null;
+    return new Date(data[0].commit.committer.date);
+  });
+}
+export {
+  page_tree_exports as PageTree,
+  findNeighbour,
+  flattenTree,
+  getGithubLastEdit,
+  getTableOfContents,
+  getTableOfContentsFromPortableText,
+  separatePageTree
+};

package/dist/sidebar.d.ts

@@ -0,0 +1,19 @@
+import { ReactNode, ElementType, ComponentPropsWithoutRef } from 'react';
+
+interface SidebarProviderProps {
+    open?: boolean;
+    onOpenChange?: (v: boolean) => void;
+    children: ReactNode;
+}
+declare function SidebarProvider(props: SidebarProviderProps): JSX.Element;
+type WithAs<T extends ElementType, Extend = object> = Omit<ComponentPropsWithoutRef<T>, 'as' | keyof Extend> & Extend & {
+    as?: T;
+};
+type SidebarTriggerProps<T extends ElementType> = WithAs<T>;
+declare function SidebarTrigger<T extends ElementType = 'button'>({ as, ...props }: SidebarTriggerProps<T>): JSX.Element;
+type SidebarContentProps<T extends ElementType> = WithAs<T, {
+    minWidth?: number;
+}>;
+declare function SidebarList<T extends ElementType = 'aside'>({ as, minWidth, ...props }: SidebarContentProps<T>): JSX.Element;
+
+export { type SidebarContentProps, SidebarList, SidebarProvider, type SidebarProviderProps, SidebarTrigger, type SidebarTriggerProps };