fumadocs-core 8.0.0

package/dist/mdx-plugins/index.js

@@ -0,0 +1,353 @@
+import {
+  flattenNode,
+  remarkHeading,
+  visit
+} from "../chunk-GT3Y35O6.js";
+import {
+  slash
+} from "../chunk-2ZGUSAWB.js";
+import {
+  __async,
+  __spreadValues
+} from "../chunk-WEAGW6MQ.js";
+
+// src/mdx-plugins/index.ts
+import {
+  default as default2
+} from "remark-gfm";
+
+// src/mdx-plugins/rehype-code.ts
+import rehypeShikiji from "rehype-shikiji";
+import {
+  transformerNotationHighlight,
+  transformerNotationWordHighlight
+} from "shikiji-transformers";
+
+// src/mdx-plugins/hast-utils.ts
+function visit2(node, tagNames, handler) {
+  if (node.type === "element") {
+    if (tagNames.includes(node.tagName)) {
+      handler(node);
+      return;
+    }
+  }
+  if ("children" in node)
+    node.children.forEach((n) => {
+      visit2(n, tagNames, handler);
+    });
+}
+
+// src/mdx-plugins/rehype-code.ts
+var metaValues = [
+  {
+    name: "title",
+    regex: new RegExp('title="(?<value>[^"]*)"')
+  },
+  {
+    name: "custom",
+    regex: new RegExp('custom="(?<value>[^"]+)"')
+  }
+];
+var rehypeCodeDefaultOptions = {
+  themes: {
+    light: "github-light",
+    dark: "github-dark"
+  },
+  defaultLang: "plaintext",
+  defaultColor: false,
+  transformers: [
+    transformerNotationHighlight(),
+    transformerNotationWordHighlight()
+  ],
+  parseMetaString(meta) {
+    const map = {};
+    for (const value of metaValues) {
+      const result = value.regex.exec(meta);
+      if (result == null ? void 0 : result.groups) {
+        map[value.name] = result.groups.value;
+      }
+    }
+    return map;
+  },
+  filterMetaString(meta) {
+    let replaced = meta;
+    for (const value of metaValues) {
+      replaced = replaced.replace(value.regex, "");
+    }
+    return replaced;
+  }
+};
+function rehypeCode(options = {}) {
+  const codeOptions = __spreadValues(__spreadValues({}, rehypeCodeDefaultOptions), options);
+  codeOptions.transformers || (codeOptions.transformers = []);
+  codeOptions.transformers = [
+    {
+      name: "rehype-code:filter-meta",
+      preprocess(code, { meta }) {
+        var _a;
+        if (meta && codeOptions.filterMetaString) {
+          meta.__raw = codeOptions.filterMetaString((_a = meta.__raw) != null ? _a : "");
+        }
+        return code.replace(/\n$/, "");
+      }
+    },
+    ...codeOptions.transformers
+  ];
+  const prefix = "language-";
+  const transformer = rehypeShikiji.call(this, codeOptions);
+  return (root, vfile) => __async(this, null, function* () {
+    visit2(root, ["pre"], (element) => {
+      var _a;
+      const head = element.children[0];
+      if (element.children.length === 0 || head.type !== "element" || head.tagName !== "code")
+        return;
+      (_a = head.properties).className || (_a.className = []);
+      const classes = head.properties.className;
+      if (!Array.isArray(classes))
+        return;
+      const hasLanguage = classes.some(
+        (d) => typeof d === "string" && d.startsWith(prefix)
+      );
+      if (!hasLanguage && codeOptions.defaultLang)
+        classes.push(`${prefix}${codeOptions.defaultLang}`);
+    });
+    if (transformer)
+      yield transformer.call(this, root, vfile, () => {
+      });
+  });
+}
+
+// src/mdx-plugins/remark-image.ts
+import { existsSync } from "fs";
+import path from "path";
+var VALID_BLUR_EXT = [".jpeg", ".png", ".webp", ".avif", ".jpg"];
+var EXTERNAL_URL_REGEX = /^https?:\/\//;
+var PUBLIC_DIR = path.join(process.cwd(), "public");
+function remarkImage({
+  placeholder = "blur"
+} = {}) {
+  return (tree, _file, done) => {
+    const importsToInject = [];
+    visit(tree, ["image"], (node) => {
+      var _a;
+      let url = decodeURI(node.url);
+      if (!url || EXTERNAL_URL_REGEX.test(url)) {
+        return;
+      }
+      if (url.startsWith("/")) {
+        const urlPath = path.join(PUBLIC_DIR, url);
+        if (!existsSync(urlPath)) {
+          return;
+        }
+        url = slash(urlPath);
+      }
+      const variableName = `__img${importsToInject.length}`;
+      const hasBlur = placeholder === "blur" && VALID_BLUR_EXT.some((ext) => url.endsWith(ext));
+      importsToInject.push({ variableName, importPath: url });
+      Object.assign(node, {
+        type: "mdxJsxFlowElement",
+        name: "img",
+        attributes: [
+          {
+            type: "mdxJsxAttribute",
+            name: "alt",
+            value: (_a = node.alt) != null ? _a : "image"
+          },
+          hasBlur && {
+            type: "mdxJsxAttribute",
+            name: "placeholder",
+            value: "blur"
+          },
+          {
+            type: "mdxJsxAttribute",
+            name: "src",
+            value: {
+              type: "mdxJsxAttributeValueExpression",
+              value: variableName,
+              data: {
+                estree: {
+                  body: [
+                    {
+                      type: "ExpressionStatement",
+                      expression: { type: "Identifier", name: variableName }
+                    }
+                  ]
+                }
+              }
+            }
+          }
+        ].filter(Boolean)
+      });
+    });
+    if (importsToInject.length) {
+      const imports = importsToInject.map(
+        ({ variableName, importPath }) => ({
+          type: "mdxjsEsm",
+          data: {
+            estree: {
+              body: [
+                {
+                  type: "ImportDeclaration",
+                  source: { type: "Literal", value: importPath },
+                  specifiers: [
+                    {
+                      type: "ImportDefaultSpecifier",
+                      local: { type: "Identifier", name: variableName }
+                    }
+                  ]
+                }
+              ]
+            }
+          }
+        })
+      );
+      tree.children.unshift(...imports);
+    }
+    done();
+  };
+}
+
+// src/mdx-plugins/remark-dynamic-content.ts
+import fs from "fs";
+import path2 from "path";
+var regex = new RegExp("^\\|reference:(?<path>.+)\\|");
+function remarkDynamicContent(options = {}) {
+  const {
+    cwd = process.cwd(),
+    trim = true,
+    visit: filter = ["text", "code"]
+  } = options;
+  return (tree) => {
+    visit(tree, filter, (node) => {
+      var _a;
+      if (!("value" in node) || typeof node.value !== "string")
+        return;
+      const result = regex.exec(node.value);
+      if ((_a = result == null ? void 0 : result.groups) == null ? void 0 : _a.path) {
+        const dest = path2.resolve(cwd, result[1]);
+        let value = fs.readFileSync(dest).toString();
+        if (trim)
+          value = value.trim();
+        node.value = value;
+      }
+    });
+  };
+}
+
+// src/mdx-plugins/remark-structure.ts
+import Slugger from "github-slugger";
+import { remark } from "remark";
+import remarkGfm from "remark-gfm";
+import remarkMdx from "remark-mdx";
+var slugger = new Slugger();
+function remarkStructure({
+  types = ["paragraph", "blockquote", "heading"]
+} = {}) {
+  return (node, file) => {
+    slugger.reset();
+    const data = { contents: [], headings: [] };
+    let lastHeading = "";
+    visit(node, types, (element) => {
+      var _a, _b;
+      const content = flattenNode(element).trim();
+      if (element.type === "heading") {
+        element.data || (element.data = {});
+        (_a = element.data).hProperties || (_a.hProperties = {});
+        const properties = element.data.hProperties;
+        const id = (_b = properties.id) != null ? _b : slugger.slug(content);
+        data.headings.push({
+          id,
+          content
+        });
+        lastHeading = id;
+        return "skip";
+      }
+      if (content.length > 0) {
+        data.contents.push({
+          heading: lastHeading,
+          content
+        });
+      }
+      return "skip";
+    });
+    file.data.structuredData = data;
+  };
+}
+function structure(content, remarkPlugins = [], options = {}) {
+  const result = remark().use(remarkGfm).use(remarkMdx).use(remarkPlugins).use(remarkStructure, options).processSync(content);
+  return result.data.structuredData;
+}
+
+// src/mdx-plugins/remark-install.ts
+function remarkInstall({
+  Tab = "Tab",
+  Tabs = "Tabs",
+  packageManagers = [
+    (name) => ({ command: `npm install ${name}`, packageManager: "npm" }),
+    (name) => ({ command: `pnpm add ${name}`, packageManager: "pnpm" }),
+    (name) => ({ command: `yarn add ${name}`, packageManager: "yarn" })
+  ]
+} = {}) {
+  return (tree) => {
+    visit(tree, ["code"], (node) => {
+      if (node.lang !== "package-install")
+        return "skip";
+      const managers = packageManagers.map((manager) => manager(node.value));
+      const insert = {
+        type: "mdxJsxFlowElement",
+        name: Tabs,
+        attributes: [
+          {
+            type: "mdxJsxAttribute",
+            name: "items",
+            value: {
+              type: "mdxJsxAttributeValueExpression",
+              data: {
+                estree: {
+                  body: [
+                    {
+                      type: "ExpressionStatement",
+                      expression: {
+                        type: "ArrayExpression",
+                        elements: managers.map(({ packageManager }) => ({
+                          type: "Literal",
+                          value: packageManager
+                        }))
+                      }
+                    }
+                  ]
+                }
+              }
+            }
+          }
+        ],
+        children: managers.map(({ command, packageManager }) => ({
+          type: "mdxJsxFlowElement",
+          name: Tab,
+          attributes: [
+            { type: "mdxJsxAttribute", name: "value", value: packageManager }
+          ],
+          children: [
+            {
+              type: "code",
+              lang: "bash",
+              value: command
+            }
+          ]
+        }))
+      };
+      Object.assign(node, insert);
+    });
+  };
+}
+export {
+  rehypeCode,
+  rehypeCodeDefaultOptions,
+  remarkDynamicContent,
+  default2 as remarkGfm,
+  remarkHeading,
+  remarkImage,
+  remarkInstall,
+  remarkStructure,
+  structure
+};

package/dist/middleware.d.ts

@@ -0,0 +1,10 @@
+import { NextMiddleware } from 'next/dist/server/web/types';
+
+interface MiddlewareOptions {
+    languages: string[];
+    defaultLanguage: string;
+    format?: (locale: string, path: string) => string;
+}
+declare function createI18nMiddleware({ languages, defaultLanguage, format, }: MiddlewareOptions): NextMiddleware;
+
+export { createI18nMiddleware };

package/dist/middleware.js

@@ -0,0 +1,43 @@
+import "./chunk-WEAGW6MQ.js";
+
+// src/middleware.ts
+import { match as matchLocale } from "@formatjs/intl-localematcher";
+import Negotiator from "negotiator";
+import nextLib from "next/server";
+function getLocale(request, locales, defaultLanguage) {
+  const negotiatorHeaders = {};
+  request.headers.forEach((value, key) => negotiatorHeaders[key] = value);
+  const languages = new Negotiator({ headers: negotiatorHeaders }).languages(
+    locales
+  );
+  return matchLocale(languages, locales, defaultLanguage);
+}
+var defaultFormat = (locale, path) => {
+  return `/${locale}/${path}`;
+};
+function createI18nMiddleware({
+  languages,
+  defaultLanguage,
+  format = defaultFormat
+}) {
+  return (request) => {
+    const { pathname } = request.nextUrl;
+    const pathnameIsMissingLocale = languages.every(
+      (locale) => !pathname.startsWith(`/${locale}/`) && pathname !== `/${locale}`
+    );
+    if (pathnameIsMissingLocale) {
+      const locale = getLocale(request, languages, defaultLanguage);
+      let path = pathname;
+      while (path.startsWith("/")) {
+        path = path.slice(1);
+      }
+      return nextLib.NextResponse.redirect(
+        new URL(format(locale, path), request.url)
+      );
+    }
+    return nextLib.NextResponse.next();
+  };
+}
+export {
+  createI18nMiddleware
+};

package/dist/page-tree-izSPERQk.d.ts

@@ -0,0 +1,37 @@
+import { ReactElement } from 'react';
+
+interface Root {
+    name: string;
+    children: Node[];
+}
+type Node = Item | Separator | Folder;
+interface Item {
+    type: 'page';
+    name: string;
+    url: string;
+    external?: boolean;
+    icon?: ReactElement;
+}
+interface Separator {
+    type: 'separator';
+    name: string;
+}
+interface Folder {
+    type: 'folder';
+    name: string;
+    root?: boolean;
+    index?: Item;
+    icon?: ReactElement;
+    children: Node[];
+}
+
+type pageTree_Folder = Folder;
+type pageTree_Item = Item;
+type pageTree_Node = Node;
+type pageTree_Root = Root;
+type pageTree_Separator = Separator;
+declare namespace pageTree {
+  export type { pageTree_Folder as Folder, pageTree_Item as Item, pageTree_Node as Node, pageTree_Root as Root, pageTree_Separator as Separator };
+}
+
+export { type Item as I, type Node as N, type Root as R, pageTree as p };

package/dist/remark-structure-RwYPDA6M.d.ts

@@ -0,0 +1,34 @@
+import { Root } from 'mdast';
+import { Transformer, PluggableList } from 'unified';
+
+interface Heading {
+    id: string;
+    content: string;
+}
+interface Content {
+    heading: string | undefined;
+    content: string;
+}
+interface StructuredData {
+    headings: Heading[];
+    /**
+     * Refer to paragraphs, a heading may contains multiple contents as well
+     */
+    contents: Content[];
+}
+interface Options {
+    /**
+     * Types to be scanned, default: `["heading", "blockquote", "paragraph"]`
+     */
+    types?: string[];
+}
+/**
+ * Attach structured data to VFile, you can access via `vfile.data.structuredData`.
+ */
+declare function remarkStructure({ types, }?: Options): Transformer<Root, Root>;
+/**
+ * Extract data from markdown/mdx content
+ */
+declare function structure(content: string, remarkPlugins?: PluggableList, options?: Options): StructuredData;
+
+export { type StructuredData as S, remarkStructure as r, structure as s };

package/dist/search/client.d.ts

@@ -0,0 +1,13 @@
+import { SWRResponse } from 'swr';
+import { SortedResult } from './shared.js';
+
+interface UseDocsSearch {
+    search: string;
+    setSearch: (v: string) => void;
+    query: SWRResponse<SortedResult[] | 'empty', Error, {
+        keepPreviousData: true;
+    }>;
+}
+declare function useDocsSearch(locale?: string, tag?: string): UseDocsSearch;
+
+export { useDocsSearch };

package/dist/search/client.js

@@ -0,0 +1,52 @@
+import {
+  __async
+} from "../chunk-WEAGW6MQ.js";
+
+// src/search/client.ts
+import { useEffect, useState } from "react";
+import useSWR from "swr";
+function fetchDocs(api, query, locale, tag) {
+  return __async(this, null, function* () {
+    if (query.length === 0)
+      return "empty";
+    const params = new URLSearchParams();
+    params.set("query", query);
+    if (locale)
+      params.set("locale", locale);
+    if (tag)
+      params.set("tag", tag);
+    const res = yield fetch(`${api}?${params.toString()}`);
+    if (!res.ok)
+      throw new Error(yield res.text());
+    return yield res.json();
+  });
+}
+function useDocsSearch(locale, tag) {
+  const [search, setSearch] = useState("");
+  const debouncedValue = useDebounce(search, 100);
+  const query = useSWR(
+    ["/api/search", debouncedValue, locale, tag],
+    (_0) => __async(this, [_0], function* ([api, value]) {
+      return fetchDocs(api, value, locale, tag);
+    }),
+    {
+      keepPreviousData: true
+    }
+  );
+  return { search, setSearch, query };
+}
+function useDebounce(value, delayMs = 1e3) {
+  const [debouncedValue, setDebouncedValue] = useState(value);
+  useEffect(() => {
+    const handler = setTimeout(() => {
+      setDebouncedValue(value);
+    }, delayMs);
+    return () => {
+      clearTimeout(handler);
+    };
+  }, [value, delayMs]);
+  return debouncedValue;
+}
+export {
+  useDocsSearch
+};

package/dist/search/server.d.ts

@@ -0,0 +1,51 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { S as StructuredData } from '../remark-structure-RwYPDA6M.js';
+import { SortedResult } from './shared.js';
+import 'mdast';
+import 'unified';
+
+interface SearchAPI {
+    GET: (request: NextRequest) => NextResponse<SortedResult[]> | Promise<NextResponse<SortedResult[]>>;
+}
+interface SimpleOptions {
+    indexes: Index[];
+    language?: string;
+}
+interface AdvancedOptions {
+    indexes: AdvancedIndex[];
+    /**
+     * Enabled custom tags
+     */
+    tag?: boolean;
+    language?: string;
+}
+type ToI18n<T extends {
+    indexes: unknown;
+}> = Omit<T, 'indexes' | 'language'> & {
+    indexes: [language: string, indexes: T['indexes']][];
+};
+declare function createSearchAPI<T extends 'simple' | 'advanced'>(type: T, options: T extends 'simple' ? SimpleOptions : AdvancedOptions): SearchAPI;
+declare function createI18nSearchAPI<T extends 'simple' | 'advanced'>(type: T, options: ToI18n<T extends 'simple' ? SimpleOptions : AdvancedOptions>): SearchAPI;
+interface Index {
+    title: string;
+    content: string;
+    url: string;
+    keywords?: string;
+}
+declare function initSearchAPI({ indexes, language }: SimpleOptions): SearchAPI;
+interface AdvancedIndex {
+    id: string;
+    title: string;
+    /**
+     * Required if `tag` is enabled
+     */
+    tag?: string;
+    /**
+     * preprocess mdx content with `structure`
+     */
+    structuredData: StructuredData;
+    url: string;
+}
+declare function initSearchAPIAdvanced({ indexes, language, tag, }: AdvancedOptions): SearchAPI;
+
+export { createI18nSearchAPI, createSearchAPI, initSearchAPI, initSearchAPIAdvanced };