fumadocs-core 8.0.0

package/dist/sidebar.js

@@ -0,0 +1,88 @@
+import {
+  __objRest,
+  __spreadProps,
+  __spreadValues
+} from "./chunk-WEAGW6MQ.js";
+
+// src/sidebar.tsx
+import { usePathname } from "next/navigation";
+import { createContext, useContext, useEffect, useState } from "react";
+import { RemoveScroll } from "react-remove-scroll";
+import { jsx } from "react/jsx-runtime";
+var SidebarContext = createContext(void 0);
+function useSidebarContext() {
+  const ctx = useContext(SidebarContext);
+  if (!ctx)
+    throw new Error("Missing sidebar provider");
+  return ctx;
+}
+function SidebarProvider(props) {
+  var _a, _b;
+  const [openInner, setOpenInner] = useState(false);
+  const [open, setOpen] = [
+    (_a = props.open) != null ? _a : openInner,
+    (_b = props.onOpenChange) != null ? _b : setOpenInner
+  ];
+  const pathname = usePathname();
+  useEffect(() => {
+    setOpen(false);
+  }, [pathname]);
+  return /* @__PURE__ */ jsx(SidebarContext.Provider, { value: [open, setOpen], children: props.children });
+}
+function SidebarTrigger(_a) {
+  var _b = _a, {
+    as
+  } = _b, props = __objRest(_b, [
+    "as"
+  ]);
+  const [open, setOpen] = useSidebarContext();
+  const As = as != null ? as : "button";
+  return /* @__PURE__ */ jsx(
+    As,
+    __spreadValues({
+      "data-open": open,
+      onClick: () => {
+        setOpen(!open);
+      }
+    }, props)
+  );
+}
+function SidebarList(_a) {
+  var _b = _a, {
+    as,
+    minWidth
+  } = _b, props = __objRest(_b, [
+    "as",
+    "minWidth"
+  ]);
+  const [open] = useSidebarContext();
+  const [isMobileLayout, setIsMobileLayout] = useState(false);
+  useEffect(() => {
+    if (minWidth === void 0)
+      return;
+    const mediaQueryList = window.matchMedia(`(min-width: ${minWidth}px)`);
+    const handleChange = () => {
+      setIsMobileLayout(!mediaQueryList.matches);
+    };
+    handleChange();
+    mediaQueryList.addEventListener("change", handleChange);
+    return () => {
+      mediaQueryList.removeEventListener("change", handleChange);
+    };
+  }, [minWidth]);
+  return /* @__PURE__ */ jsx(
+    RemoveScroll,
+    __spreadProps(__spreadValues({
+      as: as != null ? as : "aside",
+      "data-open": isMobileLayout ? open : false,
+      enabled: isMobileLayout ? open : false
+    }, props), {
+      children: props.children
+    })
+  );
+}
+export {
+  SidebarList,
+  SidebarProvider,
+  SidebarTrigger
+};

package/dist/source/index.d.ts

@@ -0,0 +1,171 @@
+import { ReactElement } from 'react';
+import { R as Root } from '../page-tree-izSPERQk.js';
+
+interface LoadOptions {
+    files: VirtualFile[];
+    transformers?: Transformer[];
+    rootDir: string;
+    getSlugs: (info: FileInfo) => string[];
+    getUrl: (slugs: string[], locale?: string) => string;
+}
+interface VirtualFile {
+    path: string;
+    type: 'page' | 'meta';
+    data: unknown;
+}
+interface LoadResult {
+    storage: Storage;
+    getSlugs: (info: FileInfo) => string[];
+    getUrl: (slugs: string[], locale?: string) => string;
+    data: Record<string, unknown>;
+}
+declare function load(options: LoadOptions): LoadResult;
+
+interface LoaderConfig {
+    source: SourceConfig;
+    i18n: boolean;
+}
+interface SourceConfig {
+    pageData: PageData;
+    metaData: MetaData;
+}
+interface LoaderOptions {
+    /**
+     * @defaultValue `''`
+     */
+    rootDir?: string;
+    /**
+     * @defaultValue `'/'`
+     */
+    baseUrl?: string;
+    languages?: string[];
+    icon?: NonNullable<CreatePageTreeBuilderOptions['resolveIcon']>;
+    slugs?: LoadOptions['getSlugs'];
+    url?: LoadOptions['getUrl'];
+    source: Source<any>;
+    transformers?: Transformer[];
+}
+interface Source<Config extends SourceConfig> {
+    /**
+     * @internal
+     */
+    _config?: Config;
+    files: VirtualFile[] | ((rootDir: string) => VirtualFile[]);
+}
+interface LoaderOutput<Config extends LoaderConfig> {
+    pageTree: Config['i18n'] extends true ? Record<string, Root> : Root;
+    files: Node<Config['source']['metaData'], Config['source']['pageData']>[];
+    /**
+     * Get list of pages from language, empty if language hasn't specified
+     *
+     * @param language - If empty, the default language will be used
+     */
+    getPages: (language?: string) => Page<Config['source']['pageData']>[];
+    /**
+     * @param language - If empty, the default language will be used
+     */
+    getPage: (slugs: string[] | undefined, language?: string) => Page<Config['source']['pageData']> | undefined;
+}
+type InferSourceConfig<T> = T extends Source<infer Config> ? Config : never;
+declare function loader<Options extends LoaderOptions>(options: Options): LoaderOutput<{
+    source: InferSourceConfig<Options['source']>;
+    i18n: Options['languages'] extends string[] ? true : false;
+}>;
+
+interface FileInfo {
+    locale?: string;
+    /**
+     * Original path of file
+     */
+    path: string;
+    /**
+     * File path without extension
+     */
+    flattenedPath: string;
+    /**
+     * File name without locale and extension
+     */
+    name: string;
+    dirname: string;
+}
+interface MetaData {
+    icon?: string;
+    title?: string;
+    root?: boolean;
+    pages?: string[];
+}
+interface PageData {
+    icon?: string;
+    title: string;
+}
+type InferPageType<Utils extends LoaderOutput<any>> = Utils extends LoaderOutput<infer Config> ? Page<Config['source']['pageData']> : never;
+type InferMetaType<Utils extends LoaderOutput<any>> = Utils extends LoaderOutput<infer Config> ? Meta<Config['source']['metaData']> : never;
+type Transformer = (context: LoadResult) => void;
+
+interface Meta<Data extends MetaData = MetaData> {
+    type: 'meta';
+    file: FileInfo;
+    data: Data;
+}
+interface Page<Data extends PageData = PageData> {
+    type: 'page';
+    file: FileInfo;
+    slugs: string[];
+    url: string;
+    data: Data;
+}
+interface Folder<MD extends MetaData = MetaData, PD extends PageData = PageData> {
+    type: 'folder';
+    file: FileInfo;
+    children: Node<MD, PD>[];
+}
+type Node<MD extends MetaData = MetaData, PD extends PageData = PageData> = Meta<MD> | Page<PD> | Folder;
+/**
+ * A virtual file system that solves inconsistent behaviours
+ *
+ * Some source providers may not provide the full file structure, this will cause inconsistent outputs for page builder and other transformers
+ */
+declare class Storage {
+    files: Map<string, Page<PageData> | Meta<MetaData>>;
+    folders: Map<string, Folder<MetaData, PageData>>;
+    private rootFolder;
+    constructor();
+    /**
+     * Read a file, it doesn't need an extension
+     * @param path - flattened path
+     */
+    read(path: string): Page | Meta | undefined;
+    readDir(path: string): Folder | undefined;
+    root(): Folder;
+    write(path: string, file: Omit<Page, 'file'> | Omit<Meta, 'file'>): void;
+    list(): (Page | Meta)[];
+    makeDir(path: string): void;
+}
+
+type fileSystem_Folder<MD extends MetaData = MetaData, PD extends PageData = PageData> = Folder<MD, PD>;
+type fileSystem_Meta<Data extends MetaData = MetaData> = Meta<Data>;
+type fileSystem_Node<MD extends MetaData = MetaData, PD extends PageData = PageData> = Node<MD, PD>;
+type fileSystem_Page<Data extends PageData = PageData> = Page<Data>;
+type fileSystem_Storage = Storage;
+declare const fileSystem_Storage: typeof Storage;
+declare namespace fileSystem {
+  export { type fileSystem_Folder as Folder, type fileSystem_Meta as Meta, type fileSystem_Node as Node, type fileSystem_Page as Page, fileSystem_Storage as Storage };
+}
+
+interface BuildPageTreeOptionsWithI18n {
+    languages: string[];
+}
+interface PageTreeBuilder {
+    build: () => Root;
+    /**
+     * Build page tree and fallback to the default language if the page doesn't exist
+     */
+    buildI18n: (options?: Partial<BuildPageTreeOptionsWithI18n>) => Record<string, Root>;
+}
+interface CreatePageTreeBuilderOptions {
+    storage: Storage;
+    resolveIcon?: (icon: string) => ReactElement | undefined;
+}
+declare function createPageTreeBuilder({ storage, resolveIcon, }: CreatePageTreeBuilderOptions): PageTreeBuilder;
+
+export { type BuildPageTreeOptionsWithI18n, type CreatePageTreeBuilderOptions, type FileInfo, fileSystem as FileSystem, type InferMetaType, type InferPageType, type LoadOptions, type LoadResult, type LoaderOptions, type LoaderOutput, type MetaData, type PageData, type PageTreeBuilder, type Source, type Transformer, type VirtualFile, createPageTreeBuilder, load, loader };

package/dist/source/index.js

@@ -0,0 +1,389 @@
+import {
+  slash
+} from "../chunk-2ZGUSAWB.js";
+import {
+  __export,
+  __spreadProps,
+  __spreadValues
+} from "../chunk-WEAGW6MQ.js";
+
+// src/source/path.ts
+import { parse } from "path";
+function parseFilePath(path) {
+  const parsed = parse(path);
+  const dir = slash(parsed.dir);
+  const flattenedPath = joinPaths([dir, parsed.name]);
+  const [name, locale] = parsed.name.split(".");
+  return {
+    dirname: dir,
+    name,
+    flattenedPath,
+    locale,
+    path
+  };
+}
+function isRelative(path, root) {
+  return path.startsWith(root);
+}
+function getRelativePath(path, root) {
+  if (!isRelative(path, root))
+    throw new Error("Invalid path");
+  return splitPath(path.substring(root.length)).join("/");
+}
+function parseFolderPath(path) {
+  const parsed = parse(path);
+  const dir = parsed.dir.replace("\\", "/");
+  const [name, locale] = parsed.base.split(".");
+  return {
+    dirname: dir,
+    name,
+    flattenedPath: path,
+    locale,
+    path
+  };
+}
+function splitPath(path) {
+  return path.split("/").filter((p) => p.length > 0);
+}
+function joinPaths(paths, slashMode = "none") {
+  const joined = paths.flatMap((path) => splitPath(path)).join("/");
+  switch (slashMode) {
+    case "leading":
+      return `/${joined}`;
+    case "trailing":
+      return `${joined}/`;
+    default:
+      return joined;
+  }
+}
+
+// src/source/page-tree-builder.ts
+var separator = new RegExp("---(?<name>.*?)---");
+var rest = "...";
+var extractor = new RegExp("\\.\\.\\.(?<name>.+)");
+function buildAll(nodes, ctx, skipIndex) {
+  const output = [];
+  for (const node of [...nodes].sort(
+    (a, b) => a.file.name.localeCompare(b.file.name)
+  )) {
+    if (node.type === "page") {
+      if (node.file.locale)
+        continue;
+      const treeNode = buildFileNode(node, ctx);
+      if (node.file.name === "index") {
+        if (!skipIndex)
+          output.unshift(treeNode);
+        continue;
+      }
+      output.push(treeNode);
+    }
+    if (node.type === "folder") {
+      output.push(buildFolderNode(node, ctx));
+    }
+  }
+  return output;
+}
+function getFolderMeta(folder, ctx) {
+  var _a;
+  let meta = ctx.storage.read(joinPaths([folder.file.path, "meta"]));
+  if (ctx.lang) {
+    meta = (_a = ctx.storage.read(joinPaths([folder.file.path, `meta.${ctx.lang}`]))) != null ? _a : meta;
+  }
+  if ((meta == null ? void 0 : meta.type) === "meta")
+    return meta;
+}
+function buildFolderNode(folder, ctx, root = false) {
+  var _a, _b, _c, _d, _e;
+  const indexNode = folder.children.find(
+    (node) => node.type === "page" && node.file.name === "index"
+  );
+  const index = indexNode ? buildFileNode(indexNode, ctx) : void 0;
+  const meta = (_a = getFolderMeta(folder, ctx)) == null ? void 0 : _a.data;
+  let children;
+  if (!meta) {
+    children = buildAll(folder.children, ctx, !root);
+  } else {
+    const isRoot = (_b = meta.root) != null ? _b : root;
+    const addedNodePaths = /* @__PURE__ */ new Set();
+    const resolved = (_c = meta.pages) == null ? void 0 : _c.flatMap((item) => {
+      var _a2, _b2, _c2;
+      if (item === rest)
+        return "...";
+      const result = separator.exec(item);
+      if (result == null ? void 0 : result.groups) {
+        return {
+          type: "separator",
+          name: result.groups.name
+        };
+      }
+      const extractResult = extractor.exec(item);
+      const extractName = (_b2 = (_a2 = extractResult == null ? void 0 : extractResult.groups) == null ? void 0 : _a2.name) != null ? _b2 : item;
+      const itemNode = (_c2 = ctx.storage.readDir(joinPaths([folder.file.path, extractName]))) != null ? _c2 : ctx.storage.read(joinPaths([folder.file.path, extractName]));
+      if (!itemNode)
+        return [];
+      addedNodePaths.add(itemNode.file.path);
+      if (itemNode.type === "folder") {
+        const node = buildFolderNode(itemNode, ctx);
+        return (extractResult == null ? void 0 : extractResult.groups) ? node.children : node;
+      }
+      if (itemNode.type === "page") {
+        return buildFileNode(itemNode, ctx);
+      }
+      return [];
+    });
+    const restNodes = buildAll(
+      folder.children.filter((node) => !addedNodePaths.has(node.file.path)),
+      ctx,
+      !isRoot
+    );
+    const nodes = resolved == null ? void 0 : resolved.flatMap((item) => {
+      if (item === "...") {
+        return restNodes;
+      }
+      return item;
+    });
+    children = nodes != null ? nodes : restNodes;
+  }
+  return {
+    type: "folder",
+    name: (_e = (_d = meta == null ? void 0 : meta.title) != null ? _d : index == null ? void 0 : index.name) != null ? _e : pathToName(folder.file.name),
+    icon: ctx.resolveIcon(meta == null ? void 0 : meta.icon),
+    root: meta == null ? void 0 : meta.root,
+    index,
+    children
+  };
+}
+function buildFileNode(page, ctx) {
+  let localePage = page;
+  if (ctx.lang) {
+    const result = ctx.storage.read(`${page.file.flattenedPath}.${ctx.lang}`);
+    if ((result == null ? void 0 : result.type) === "page")
+      localePage = result;
+  }
+  return {
+    type: "page",
+    name: localePage.data.title,
+    icon: ctx.resolveIcon(localePage.data.icon),
+    url: localePage.url
+  };
+}
+function build(ctx) {
+  const root = ctx.storage.root();
+  const folder = buildFolderNode(root, ctx, true);
+  return {
+    name: folder.name,
+    children: folder.children
+  };
+}
+function createPageTreeBuilder({
+  storage,
+  resolveIcon = () => void 0
+}) {
+  const context = {
+    storage,
+    resolveIcon(icon) {
+      if (!icon)
+        return;
+      return resolveIcon(icon);
+    }
+  };
+  return {
+    build() {
+      return build(context);
+    },
+    buildI18n({ languages = [] } = {}) {
+      const entries = languages.map((lang) => {
+        const tree = build(__spreadProps(__spreadValues({}, context), {
+          lang
+        }));
+        return [lang, tree];
+      });
+      return Object.fromEntries(entries);
+    }
+  };
+}
+function pathToName(path) {
+  return path.slice(0, 1).toUpperCase() + path.slice(1);
+}
+
+// src/source/file-system.ts
+var file_system_exports = {};
+__export(file_system_exports, {
+  Storage: () => Storage
+});
+var Storage = class {
+  constructor() {
+    this.files = /* @__PURE__ */ new Map();
+    this.folders = /* @__PURE__ */ new Map();
+    this.rootFolder = {
+      type: "folder",
+      file: parseFolderPath(""),
+      children: []
+    };
+    this.folders.set("", this.rootFolder);
+  }
+  /**
+   * Read a file, it doesn't need an extension
+   * @param path - flattened path
+   */
+  read(path) {
+    return this.files.get(path);
+  }
+  readDir(path) {
+    return this.folders.get(path);
+  }
+  root() {
+    return this.rootFolder;
+  }
+  write(path, file) {
+    var _a;
+    const node = __spreadValues({
+      file: parseFilePath(path)
+    }, file);
+    this.makeDir(node.file.dirname);
+    (_a = this.readDir(node.file.dirname)) == null ? void 0 : _a.children.push(node);
+    this.files.set(node.file.flattenedPath, node);
+  }
+  list() {
+    return [...this.files.values()];
+  }
+  makeDir(path) {
+    var _a;
+    const segments = splitPath(path);
+    for (let i = 0; i < segments.length; i++) {
+      const segment = segments.slice(0, i + 1).join("/");
+      if (this.folders.has(segment))
+        continue;
+      const folder = {
+        type: "folder",
+        file: parseFolderPath(segment),
+        children: []
+      };
+      this.folders.set(folder.file.path, folder);
+      (_a = this.readDir(folder.file.dirname)) == null ? void 0 : _a.children.push(folder);
+    }
+  }
+};
+
+// src/source/load.ts
+function load(options) {
+  const { transformers = [] } = options;
+  const storage = buildStorage(options);
+  const ctx = {
+    getSlugs: options.getSlugs,
+    getUrl: options.getUrl,
+    storage,
+    data: {}
+  };
+  for (const transformer of transformers) {
+    transformer(ctx);
+  }
+  return ctx;
+}
+function buildStorage(options) {
+  const storage = new Storage();
+  for (const file of options.files) {
+    if (!isRelative(file.path, options.rootDir))
+      continue;
+    const path = getRelativePath(file.path, options.rootDir);
+    if (file.type === "page") {
+      const parsedPath = parseFilePath(path);
+      const slugs = options.getSlugs(parsedPath);
+      storage.write(path, {
+        slugs,
+        url: options.getUrl(slugs, parsedPath.locale),
+        type: file.type,
+        data: file.data
+      });
+    }
+    if (file.type === "meta") {
+      storage.write(path, {
+        type: file.type,
+        data: file.data
+      });
+    }
+  }
+  return storage;
+}
+
+// src/source/create.ts
+function groupByLanguages(nodes, languages) {
+  var _a, _b, _c;
+  const pageMap = /* @__PURE__ */ new Map();
+  for (const node of nodes) {
+    if (node.type === "page")
+      pageMap.set(node.file.flattenedPath, node);
+  }
+  const langMap = /* @__PURE__ */ new Map();
+  langMap.set("", []);
+  for (const lang of languages) {
+    langMap.set(lang, []);
+  }
+  for (const [key, node] of pageMap) {
+    if (node.file.locale)
+      continue;
+    (_a = langMap.get("")) == null ? void 0 : _a.push(node);
+    for (const lang of languages) {
+      const v = (_b = pageMap.get(`${key}.${lang}`)) != null ? _b : node;
+      (_c = langMap.get(lang)) == null ? void 0 : _c.push(v);
+    }
+  }
+  return langMap;
+}
+function createGetUrl(baseUrl) {
+  return (slugs, locale) => {
+    let paths = [baseUrl, ...slugs];
+    if (locale)
+      paths = [baseUrl, locale, ...slugs];
+    return joinPaths(paths, "leading");
+  };
+}
+function loader(options) {
+  return createOutput(options);
+}
+function createOutput({
+  source,
+  icon,
+  languages,
+  rootDir = "",
+  transformers,
+  baseUrl = "/",
+  slugs = (info) => {
+    const result = [...info.dirname.split("/"), info.name].filter(Boolean);
+    return result[result.length - 1] === "index" ? result.slice(0, -1) : result;
+  },
+  url = createGetUrl(baseUrl)
+}) {
+  const result = load({
+    files: typeof source.files === "function" ? source.files(rootDir) : source.files,
+    transformers,
+    rootDir,
+    getSlugs: slugs,
+    getUrl: url
+  });
+  const i18nMap = groupByLanguages(result.storage.list(), languages != null ? languages : []);
+  const builder = createPageTreeBuilder({
+    storage: result.storage,
+    resolveIcon: icon
+  });
+  const pageTree = languages === void 0 ? builder.build() : builder.buildI18n({ languages });
+  return {
+    pageTree,
+    files: result.storage.list(),
+    getPages(language = "") {
+      var _a;
+      return (_a = i18nMap.get(language)) != null ? _a : [];
+    },
+    getPage(slugs_ = [], language = "") {
+      var _a;
+      const path = slugs_.join("/");
+      return (_a = i18nMap.get(language)) == null ? void 0 : _a.find((page) => page.slugs.join("/") === path);
+    }
+  };
+}
+export {
+  file_system_exports as FileSystem,
+  createPageTreeBuilder,
+  load,
+  loader
+};

package/dist/toc.d.ts

@@ -0,0 +1,20 @@
+import * as react from 'react';
+import { HTMLAttributes, AnchorHTMLAttributes } from 'react';
+import { T as TableOfContents, a as TOCItemType } from './get-toc-YF_TdazL.js';
+
+declare const useActiveAnchor: (url: string) => boolean;
+declare const TOCProvider: react.ForwardRefExoticComponent<HTMLAttributes<HTMLDivElement> & {
+    toc: TableOfContents;
+} & react.RefAttributes<HTMLDivElement>>;
+type TOCItemProps = AnchorHTMLAttributes<HTMLAnchorElement> & {
+    href: string;
+    /** @deprecated You don't need to pass this anymore */
+    item?: TOCItemType;
+};
+declare const TOCItem: react.ForwardRefExoticComponent<AnchorHTMLAttributes<HTMLAnchorElement> & {
+    href: string;
+    /** @deprecated You don't need to pass this anymore */
+    item?: TOCItemType | undefined;
+} & react.RefAttributes<HTMLAnchorElement>>;
+
+export { TOCItem, type TOCItemProps, TOCProvider, useActiveAnchor };