@vezham/docs-core 1.0.1

package/dist/server.js

@@ -0,0 +1,398 @@
+import { isValidElement } from "react";
+import { AsyncLocalStorage } from "node:async_hooks";
+//#region src/server.ts
+const ROOT_STATE = {
+	pre: false,
+	inline: false,
+	heading: false
+};
+const CLIENT_REFERENCE = Symbol.for("react.client.reference");
+const REACT_LAZY = Symbol.for("react.lazy");
+const REACT_MEMO = Symbol.for("react.memo");
+const REACT_FORWARD_REF = Symbol.for("react.forward_ref");
+const NOT_OPTED_IN = Symbol();
+const store = new AsyncLocalStorage({ name: "fumadocs:markdown" });
+/**
+* Whether the current component is being rendered into Markdown, calling it opts the component in.
+*/
+function asMarkdown() {
+	const frame = store.getStore();
+	if (!frame) return false;
+	frame.optedIn = true;
+	return true;
+}
+/**
+* Render a React tree into a Markdown document.
+*/
+async function renderToMarkdown(node) {
+	return collapse(await walk(node, ROOT_STATE)).trim();
+}
+/**
+* Render a page element into Markdown, `undefined` when its component doesn't call `asMarkdown()`.
+*/
+async function renderRoute(element) {
+	if (typeof element.type !== "function") return;
+	const result = await optIn(element.type, element.props);
+	if (result !== NOT_OPTED_IN) return renderToMarkdown(result);
+}
+/**
+* Resolve the MDX components of a generated Markdown component (`remarkLLMs` with `output: 'function'`):
+* a missing component becomes a stub that `renderToMarkdown` serializes as JSX syntax.
+*/
+function jsxComponents(components) {
+	return new Proxy(components ?? {}, { get(target, key) {
+		const value = target[key];
+		if (value !== void 0 || typeof key !== "string") return value;
+		const stub = () => null;
+		stub.displayName = key;
+		return stub;
+	} });
+}
+/**
+* Tagged template for Markdown, interpolated values can be strings, React nodes, promises, or arrays of them.
+*
+* Use `md\`${children}\`` inside a component to stringify its children before manipulating them, the result is not
+* trimmed so block-level output keeps its trailing blank line.
+*
+* Formatters (Prettier, oxfmt) format `md` templates as Markdown and may move the content onto its own indented lines,
+* so a leading empty line, the indentation before the closing backtick and the common indentation are removed.
+*/
+const md = Object.assign(async function md(strings, ...values) {
+	const parts = dedent(strings);
+	const resolved = await Promise.all(values.map(render));
+	let out = parts[0];
+	for (let i = 0; i < resolved.length; i++) out += resolved[i] + parts[i + 1];
+	return out;
+}, {
+	linePrefix(prefix) {
+		return async (strings, ...values) => {
+			const text = (await md(strings, ...values)).trim();
+			return text.length === 0 ? "" : `\n${prefixLines(text, prefix)}\n\n`;
+		};
+	},
+	indent(size = 2) {
+		return md.linePrefix(" ".repeat(size));
+	}
+});
+/** stands in for interpolations while dedenting, so their lines count as content */
+const PLACEHOLDER = "\0";
+function dedent(strings) {
+	const lines = strings.join(PLACEHOLDER).split("\n");
+	if (lines.length === 1) return [...strings];
+	if (lines[0].trim().length === 0) lines.shift();
+	const last = lines[lines.length - 1];
+	if (lines.length > 1 && last.length > 0 && last.trim().length === 0) lines.pop();
+	let indent = Infinity;
+	for (const line of lines) if (line.trim().length > 0) indent = Math.min(indent, /^[ \t]*/.exec(line)[0].length);
+	let out = "";
+	for (let i = 0; i < lines.length; i++) {
+		if (i > 0) out += "\n";
+		out += indent === Infinity ? lines[i] : lines[i].slice(Math.min(indent, lines[i].length));
+	}
+	return out.split(PLACEHOLDER);
+}
+async function render(node) {
+	return collapse(await walk(node, ROOT_STATE));
+}
+/**
+* Prefix every line, empty lines receive the trimmed prefix (e.g. `>` instead of `> `).
+*/
+function prefixLines(text, prefix) {
+	const empty = prefix.trimEnd();
+	return text.replace(/^.*$/gm, (line) => line.length === 0 ? empty : prefix + line);
+}
+function collapse(text) {
+	return text.replace(/\n{3,}/g, "\n\n");
+}
+/**
+* Render a component in its own frame, `NOT_OPTED_IN` when it never calls `asMarkdown()`.
+*
+* A component that throws before opting in (e.g. it needs a context that only exists on its own route) is treated the
+* same, it has no Markdown form.
+*/
+async function optIn(component, props) {
+	const frame = { optedIn: false };
+	try {
+		const result = await store.run(frame, () => component(props));
+		return frame.optedIn ? result : NOT_OPTED_IN;
+	} catch (e) {
+		if (frame.optedIn) throw e;
+		return NOT_OPTED_IN;
+	}
+}
+async function walk(node, state) {
+	if (node === null || node === void 0 || typeof node === "boolean") return "";
+	if (typeof node === "string") return node;
+	if (typeof node === "number" || typeof node === "bigint") return String(node);
+	if (isThenable(node)) return walk(await node, state);
+	if (isValidElement(node)) return element(node.type, node.props, state);
+	if (typeof node === "object" && Symbol.iterator in node) return (await Promise.all(Array.from(node, (child) => walk(child, state)))).join("");
+	return "";
+}
+async function element(type, props, state) {
+	if (typeof type === "string") return host(type, props, state);
+	if (isClientReference(type)) return jsx(clientReferenceName(type.$$id), props, state);
+	if (typeof type === "function") return component(type, props, state);
+	if (typeof type === "symbol") return walk(props.children, state);
+	if (typeof type === "object" && type !== null) {
+		const special = type;
+		switch (special.$$typeof) {
+			case REACT_LAZY: return element(await resolveLazy(special), props, state);
+			case REACT_MEMO: return element(special.type, props, state);
+			case REACT_FORWARD_REF: return component(special.render, props, state);
+		}
+	}
+	return "";
+}
+async function component(fn, props, state) {
+	const result = await optIn(fn, props);
+	if (result === NOT_OPTED_IN) return jsx(componentName(fn), props, state);
+	return walk(result, state);
+}
+function componentName(fn) {
+	const { displayName, name } = fn;
+	return typeof displayName === "string" && displayName ? displayName : name || "Component";
+}
+async function resolveLazy(type) {
+	for (;;) try {
+		return type._init(type._payload);
+	} catch (e) {
+		if (!isThenable(e)) throw e;
+		await e;
+	}
+}
+/**
+* The export name of a client reference, or a PascalCase name from its file for default exports.
+*/
+function clientReferenceName(id) {
+	if (typeof id !== "string") return "Component";
+	try {
+		id = decodeURIComponent(id);
+	} catch {}
+	const hash = id.lastIndexOf("#");
+	const exportName = hash === -1 ? "" : id.slice(hash + 1);
+	if (exportName && exportName !== "default") return exportName;
+	const file = (hash === -1 ? id : id.slice(0, hash)).split(/[\\/]/).pop();
+	let name = "";
+	for (const part of file.replace(/\.[^.]+$/, "").split(/[^\w$]+/)) if (part) name += part[0].toUpperCase() + part.slice(1);
+	return name || "Component";
+}
+const MAX_ATTRIBUTE_LENGTH = 1024;
+const PRESENTATIONAL_PROPS = /* @__PURE__ */ new Set([
+	"children",
+	"className",
+	"style",
+	"tabIndex"
+]);
+/**
+* Serialize a component as JSX syntax, for components without a Markdown form.
+*/
+async function jsx(name, props, state) {
+	let open = `<${name}`;
+	for (const key in props) {
+		if (PRESENTATIONAL_PROPS.has(key)) continue;
+		const attr = attribute(key, props[key]);
+		if (attr !== void 0) open += ` ${attr}`;
+	}
+	const children = await walk(props.children, state);
+	if (state.inline) return children.trim().length === 0 ? `${open} />` : `${open}>${children}</${name}>`;
+	const body = children.trim();
+	if (body.length === 0) return `\n${open} />\n\n`;
+	return `\n${open}>\n${body}\n</${name}>\n\n`;
+}
+function attribute(key, value) {
+	if (value === true) return key;
+	if (value === false || value === null || value === void 0) return;
+	if (typeof value === "string") return value.length > MAX_ATTRIBUTE_LENGTH ? void 0 : `${key}=${JSON.stringify(value)}`;
+	if (typeof value === "number" || typeof value === "bigint") return `${key}={${value}}`;
+	if (typeof value === "function" || typeof value === "symbol" || isValidElement(value)) return;
+	try {
+		const json = JSON.stringify(value, (_, v) => isValidElement(v) ? void 0 : v);
+		if (json === void 0 || json.length > MAX_ATTRIBUTE_LENGTH) return;
+		return `${key}={${json}}`;
+	} catch {
+		return;
+	}
+}
+const INLINE_TAGS = /* @__PURE__ */ new Set([
+	"a",
+	"abbr",
+	"b",
+	"cite",
+	"code",
+	"del",
+	"em",
+	"i",
+	"kbd",
+	"label",
+	"mark",
+	"q",
+	"s",
+	"small",
+	"span",
+	"strong",
+	"sub",
+	"sup",
+	"time",
+	"u"
+]);
+const DROP_TAGS = /* @__PURE__ */ new Set([
+	"head",
+	"link",
+	"meta",
+	"noscript",
+	"script",
+	"style",
+	"svg",
+	"template",
+	"title"
+]);
+async function host(tag, props, state) {
+	if (DROP_TAGS.has(tag)) return "";
+	if (state.pre) {
+		if (tag === "br") return "\n";
+		return walk(props.children, state);
+	}
+	const children = (override) => walk(props.children, {
+		...state,
+		...override
+	});
+	switch (tag) {
+		case "p": {
+			const c = (await children({ inline: true })).trim();
+			return state.inline ? `${c} ` : `\n${c}\n\n`;
+		}
+		case "h1":
+		case "h2":
+		case "h3":
+		case "h4":
+		case "h5":
+		case "h6": {
+			const c = (await children({
+				inline: true,
+				heading: true
+			})).trim().replace(/\s*\n\s*/g, " ");
+			return `\n${"#".repeat(Number(tag[1]))} ${c}\n\n`;
+		}
+		case "a": {
+			const href = typeof props.href === "string" ? props.href : void 0;
+			const c = await children({ inline: true });
+			if (!href || state.heading && href.startsWith("#")) return c;
+			const text = c.trim();
+			return text.length === 0 ? `<${href}>` : `[${text}](${href})`;
+		}
+		case "strong":
+		case "b": return wrap(await children({ inline: true }), "**");
+		case "em":
+		case "i": return wrap(await children({ inline: true }), "*");
+		case "del":
+		case "s": return wrap(await children({ inline: true }), "~~");
+		case "code":
+		case "kbd": {
+			const c = await children({ inline: true });
+			if (c.includes("\n") && !state.inline) return codeFence(detectLang(props), c);
+			return inlineCode(c);
+		}
+		case "pre": return codeFence(detectLang(props), await children({ pre: true }));
+		case "blockquote": return `\n${prefixLines(collapse(await children({ inline: false })).trim(), "> ")}\n\n`;
+		case "ul":
+		case "ol": {
+			const ordered = tag === "ol";
+			let index = typeof props.start === "number" ? props.start : 1;
+			return `\n${(await Promise.all(flatten(props.children).map((child) => {
+				if (!isValidElement(child)) return typeof child === "string" ? child.trim() : "";
+				return walk(child, {
+					...state,
+					inline: false,
+					list: {
+						ordered,
+						index: index++
+					}
+				});
+			}))).join("")}\n`;
+		}
+		case "li": {
+			const marker = state.list?.ordered ? `${state.list.index}. ` : "- ";
+			return `${marker}${prefixLines((await children({ inline: false })).trim().replace(/\n{2,}(?=(?:[-*+] |\d+\. ))/g, "\n"), " ".repeat(marker.length)).slice(marker.length)}\n`;
+		}
+		case "img": {
+			if (typeof props.src !== "string") return "";
+			const alt = typeof props.alt === "string" ? props.alt : "";
+			return state.inline ? `![${alt}](${props.src})` : `\n![${alt}](${props.src})\n\n`;
+		}
+		case "hr": return "\n---\n\n";
+		case "br": return "\n";
+		case "table": {
+			const rows = (await children({ inline: false })).replace(/\n\s*\n/g, "\n").trim();
+			if (rows.length === 0) return "";
+			const end = rows.indexOf("\n");
+			const first = end === -1 ? rows : rows.slice(0, end);
+			return `\n${first}\n${separatorRow(first)}${end === -1 ? "" : rows.slice(end)}\n\n`;
+		}
+		case "tr": return `|${await children({ inline: false })}\n`;
+		case "th":
+		case "td": return ` ${(await children({ inline: true })).trim().replace(/\s*\n\s*/g, " ").replaceAll("|", "\\|")} |`;
+	}
+	if (INLINE_TAGS.has(tag)) return children({ inline: true });
+	const c = (await children({ inline: false })).trim();
+	return c.length === 0 ? "" : `\n${c}\n\n`;
+}
+function separatorRow(row) {
+	const cells = Math.max(1, (row.match(/(?<!\\)\|/g)?.length ?? 2) - 1);
+	return `|${" --- |".repeat(cells)}`;
+}
+function wrap(text, marker) {
+	const [, lead, core, trail] = /^(\s*)([\s\S]*?)(\s*)$/.exec(text);
+	return core ? `${lead}${marker}${core}${marker}${trail}` : text;
+}
+function codeFence(lang, code) {
+	const text = code.replace(/\n$/, "");
+	const fence = "`".repeat(Math.max(3, longestRun(text, "`") + 1));
+	return `\n${fence}${lang}\n${text}\n${fence}\n\n`;
+}
+function inlineCode(text) {
+	const fence = "`".repeat(longestRun(text, "`") + 1);
+	const pad = text.startsWith("`") || text.endsWith("`") ? " " : "";
+	return `${fence}${pad}${text}${pad}${fence}`;
+}
+function longestRun(text, char) {
+	let max = 0;
+	let current = 0;
+	for (const c of text) {
+		current = c === char ? current + 1 : 0;
+		if (current > max) max = current;
+	}
+	return max;
+}
+/** from `data-lang` or a `language-*` class name, of the element or its `<code>` child */
+function detectLang(props) {
+	const lang = props["data-lang"] ?? props.lang;
+	if (typeof lang === "string" && lang.length > 0) return lang;
+	const fromClass = (className) => typeof className === "string" ? /(?:^|\s)(?:language|lang)-([\w+#.-]+)/.exec(className)?.[1] : void 0;
+	let out = fromClass(props.className);
+	for (const child of flatten(props.children)) {
+		if (out) break;
+		if (isValidElement(child) && child.type === "code") out = fromClass(child.props.className);
+	}
+	return out ?? "";
+}
+/**
+* Direct children, flattened through arrays and fragments.
+*/
+function flatten(node, out = []) {
+	if (node === null || node === void 0 || typeof node === "boolean") return out;
+	if (isValidElement(node)) {
+		if (typeof node.type === "symbol") flatten(node.props.children, out);
+		else out.push(node);
+	} else if (typeof node === "object" && Symbol.iterator in node) for (const child of node) flatten(child, out);
+	else out.push(node);
+	return out;
+}
+function isClientReference(type) {
+	return (typeof type === "function" || typeof type === "object" && type !== null) && type.$$typeof === CLIENT_REFERENCE;
+}
+function isThenable(value) {
+	return typeof value === "object" && value !== null && typeof value.then === "function";
+}
+//#endregion
+export { asMarkdown, jsxComponents, md, renderRoute, renderToMarkdown };

package/dist/source/client/index.d.ts

@@ -0,0 +1,2 @@
+import { i as useFumadocsLoader, n as SerializedPageTree, r as deserializePageTree, t as Serialized } from "../../index-B-0R0VbS.js";
+export { Serialized, SerializedPageTree, deserializePageTree, useFumadocsLoader };

package/dist/source/client/index.js

@@ -0,0 +1,37 @@
+import { l as visit } from "../../utils-DEVq3cEC.js";
+import { useMemo } from "react";
+import { jsx } from "react/jsx-runtime";
+//#region src/source/client/index.tsx
+function deserializePageTree(serialized) {
+	const root = serialized.data;
+	visit(root, (item) => {
+		if ("icon" in item && typeof item.icon === "string") item.icon = /* @__PURE__ */ jsx("span", { dangerouslySetInnerHTML: { __html: item.icon } });
+		if (typeof item.name === "string") item.name = /* @__PURE__ */ jsx("span", {
+			className: "fd-page-tree-item-name",
+			dangerouslySetInnerHTML: { __html: item.name }
+		});
+	});
+	return root;
+}
+/**
+* Deserialize loader data that is serialized by the server-side Fumadocs `loader()`, supported:
+* - Page Tree
+*
+* other unrelated properties are kept in the output.
+*/
+function useFumadocsLoader(serialized) {
+	return useMemo(() => {
+		const out = {};
+		for (const k in serialized) {
+			const v = serialized[k];
+			if (isSerializedPageTree(v)) out[k] = deserializePageTree(v);
+			else out[k] = v;
+		}
+		return out;
+	}, [serialized]);
+}
+function isSerializedPageTree(v) {
+	return typeof v === "object" && v !== null && "$fumadocs_loader" in v && v.$fumadocs_loader === "page-tree";
+}
+//#endregion
+export { deserializePageTree, useFumadocsLoader };

package/dist/source/dynamic.d.ts

@@ -0,0 +1,2 @@
+import { h as dynamicLoader, m as DynamicLoaderConfig, p as DynamicLoader } from "../index-DIwKCYOz.js";
+export { DynamicLoader, DynamicLoaderConfig, dynamicLoader };

package/dist/source/dynamic.js

@@ -0,0 +1,2 @@
+import { t as dynamicLoader } from "../dynamic-CTsodhTH.js";
+export { dynamicLoader };

package/dist/source/index.d.ts

@@ -0,0 +1,2 @@
+import { B as ContentStoragePageFile, C as Meta, D as loader, E as createGetUrl, F as PageTreeBuilderContext, I as PageTreeOptions, L as PageTreeTransformer, O as types_d_exports, P as PageTreeBuilder, R as ContentStorage, S as LoaderPluginOption, T as ResolvedLoaderConfig, V as FileSystem, _ as InferPageType, a as MetaData, b as LoaderOutput, c as SourceUnion, d as multiple, f as update, g as InferMetaType, h as dynamicLoader, i as DynamicSource, j as getSlugs, l as StaticSource, m as DynamicLoaderConfig, n as llms, o as PageData, p as DynamicLoader, r as path_d_exports, s as Source, t as LLMsConfig, u as VirtualFile, v as LoaderConfig, w as Page, x as LoaderPlugin, y as LoaderOptions, z as ContentStorageMetaFile } from "../index-DIwKCYOz.js";
+export { type ContentStorage, type ContentStorageMetaFile, type ContentStoragePageFile, type DynamicLoader, type DynamicLoaderConfig, type DynamicSource, FileSystem, InferMetaType, InferPageType, LLMsConfig, LoaderConfig, LoaderOptions, LoaderOutput, LoaderPlugin, LoaderPluginOption, Meta, type MetaData, Page, type PageData, type PageTreeBuilder, type PageTreeBuilderContext, type PageTreeOptions, type PageTreeTransformer, path_d_exports as PathUtils, ResolvedLoaderConfig, type Source, type SourceUnion, type StaticSource, type VirtualFile, type types_d_exports as _Internal, createGetUrl, dynamicLoader, getSlugs, llms, loader, multiple, update };

package/dist/source/index.js

@@ -0,0 +1,5 @@
+import { o as path_exports } from "../path-1H5VzYiT.js";
+import { a as update, i as multiple, n as createGetUrl, o as FileSystem, r as loader, t as dynamicLoader } from "../dynamic-CTsodhTH.js";
+import { getSlugs } from "./plugins/slugs.js";
+import { llms } from "./llms.js";
+export { FileSystem, path_exports as PathUtils, createGetUrl, dynamicLoader, getSlugs, llms, loader, multiple, update };

package/dist/source/llms.d.ts

@@ -0,0 +1,2 @@
+import { n as llms, t as LLMsConfig } from "../index-DIwKCYOz.js";
+export { LLMsConfig, llms };

package/dist/source/llms.js

@@ -0,0 +1,74 @@
+//#region src/source/llms.ts
+function llms(loader, config = {}) {
+	const { TAB = "  ", renderName = (node, ctx) => {
+		if (node.type === "page") {
+			const page = loader.getNodePage(node, ctx.lang);
+			if (page?.data.title) return page.data.title;
+		} else if (node.type !== "separator") {
+			const meta = loader.getNodeMeta(node, ctx.lang);
+			if (meta?.data.title) return meta.data.title;
+		}
+		return typeof node.name === "string" ? node.name : "";
+	}, renderDescription = (node, ctx) => {
+		if (node.type === "page") {
+			const page = loader.getNodePage(node, ctx.lang);
+			if (page?.data.description) return page.data.description;
+		} else {
+			const meta = loader.getNodeMeta(node, ctx.lang);
+			if (meta?.data.description) return meta.data.description;
+		}
+		return typeof node.description === "string" ? node.description : "";
+	} } = config;
+	function formatListItem(name, description, indent) {
+		const prefix = TAB.repeat(indent);
+		description = description.trim();
+		if (description.length > 0) return `${prefix}- ${name}: ${description}`;
+		return `${prefix}- ${name}`;
+	}
+	function formatNode(node, indent, ctx) {
+		switch (node.type) {
+			case "page": return formatListItem(formatMarkdownLink(renderName(node, ctx), node.url), renderDescription(node, ctx), indent);
+			case "folder": {
+				const out = [];
+				out.push(formatListItem(renderName(node, ctx), renderDescription(node, ctx), indent));
+				if (node.index) out.push(formatNode(node.index, indent + 1, ctx));
+				for (const child of node.children) out.push(formatNode(child, indent + 1, ctx));
+				return out.join("\n");
+			}
+			case "separator": return "\n" + formatListItem(`**${renderName(node, ctx) || "Separator"}**`, "", indent);
+		}
+	}
+	function index(lang) {
+		if (loader._i18n && lang === void 0) {
+			const { languages } = loader._i18n;
+			return languages.map(index).join("\n\n");
+		}
+		const pageTree = loader.getPageTree(lang);
+		const out = [];
+		const ctx = { lang };
+		out.push(`# ${renderName(pageTree, ctx)}`, "");
+		const description = renderDescription(pageTree, ctx);
+		if (description) out.push(`> ${description}`, "");
+		for (const child of pageTree.children) out.push(formatNode(child, 0, ctx));
+		return out.join("\n");
+	}
+	return {
+		/**
+		* generate `llms.txt` content in Markdown format.
+		*
+		* use `indexNode(node)` instead for more control (e.g. add extra sections to output).
+		*/
+		index,
+		/**
+		* generate `llms.txt` content for a single page tree node.
+		*/
+		indexNode(node, lang) {
+			return formatNode(node, 0, { lang });
+		}
+	};
+}
+function formatMarkdownLink(title, url) {
+	return `[${title.replace(/([[\]])/g, "\\$1")}](${url.replace(/([()])/g, "\\$1")})`;
+}
+//#endregion
+export { llms };

package/dist/source/plugins/lucide-icons.d.ts

@@ -0,0 +1,11 @@
+import { x as LoaderPlugin } from "../../index-DIwKCYOz.js";
+import { icons } from "lucide-react";
+//#region src/source/plugins/lucide-icons.d.ts
+/**
+ * Convert icon names into Lucide Icons, requires `lucide-react` to be installed.
+ */
+declare function lucideIconsPlugin(options?: {
+  defaultIcon?: keyof typeof icons;
+}): LoaderPlugin;
+//#endregion
+export { lucideIconsPlugin };

package/dist/source/plugins/lucide-icons.js

@@ -0,0 +1,21 @@
+import { t as iconPlugin } from "../../icon-BILaoXeg.js";
+import { createElement } from "react";
+import { icons } from "lucide-react";
+//#region src/source/plugins/lucide-icons.ts
+/**
+* Convert icon names into Lucide Icons, requires `lucide-react` to be installed.
+*/
+function lucideIconsPlugin(options = {}) {
+	const { defaultIcon } = options;
+	return iconPlugin((icon = defaultIcon) => {
+		if (icon === void 0) return;
+		const Icon = icons[icon];
+		if (!Icon) {
+			console.warn(`[lucide-icons-plugin] Unknown icon detected: ${icon}.`);
+			return;
+		}
+		return createElement(Icon);
+	});
+}
+//#endregion
+export { lucideIconsPlugin };

package/dist/source/plugins/slugs.d.ts

@@ -0,0 +1,2 @@
+import { A as SlugsPluginOptions, M as slugsFromData, N as slugsPlugin, j as getSlugs, k as SlugFn } from "../../index-DIwKCYOz.js";
+export { SlugFn, SlugsPluginOptions, getSlugs, slugsFromData, slugsPlugin };

package/dist/source/plugins/slugs.js

@@ -0,0 +1,75 @@
+import { n as dirname, r as extname, t as basename } from "../../path-1H5VzYiT.js";
+//#region src/source/plugins/slugs.ts
+/**
+* Generate slugs for pages if missing.
+*/
+function slugsPlugin(optsOrFn = {}) {
+	const prepended = /* @__PURE__ */ new WeakSet();
+	const { baseSlugs = [], slugs: slugFn } = typeof optsOrFn === "function" ? { slugs: optsOrFn } : optsOrFn;
+	function generateSlugs(path, file) {
+		const out = slugFn?.(file, () => getSlugs(path)) ?? getSlugs(path);
+		prepended.add(file);
+		return baseSlugs.length > 0 ? [...baseSlugs, ...out] : out;
+	}
+	return {
+		name: "fumadocs:slugs",
+		transformStorage({ storage }) {
+			const indexFiles = [];
+			const taken = /* @__PURE__ */ new Set();
+			for (const path of storage.getFiles()) {
+				const file = storage.read(path);
+				if (!file || file.format !== "page") continue;
+				if (file.slugs) {
+					if (baseSlugs.length > 0 && !prepended.has(file)) {
+						file.slugs = [...baseSlugs, ...file.slugs];
+						prepended.add(file);
+					}
+					continue;
+				}
+				if (basename(path, extname(path)) === "index") {
+					indexFiles.push(path);
+					continue;
+				}
+				file.slugs = generateSlugs(path, file);
+				const key = file.slugs.join("/");
+				if (taken.has(key)) throw new Error(`Duplicated slugs: ${key}`);
+				taken.add(key);
+			}
+			for (const path of indexFiles) {
+				const file = storage.read(path);
+				if (file?.format !== "page") continue;
+				file.slugs = generateSlugs(path, file);
+				if (taken.has(file.slugs.join("/"))) file.slugs = [...file.slugs, "index"];
+				const key = file.slugs.join("/");
+				if (taken.has(key)) throw new Error(`Duplicated slugs: ${key}`);
+				taken.add(key);
+			}
+		}
+	};
+}
+/**
+* Generate slugs from file data (e.g. frontmatter).
+*
+* @param key - the property name in file data to generate slugs, default to `slug`.
+*/
+function slugsFromData(key = "slug") {
+	return (file) => {
+		const k = key;
+		if (k in file.data && typeof file.data[k] === "string") return file.data[k].split("/").filter((v) => v.length > 0);
+	};
+}
+const GroupRegex = /^\(.+\)$/;
+/**
+* Convert file path into slugs, also encode non-ASCII characters, so they can work in pathname
+*/
+function getSlugs(file) {
+	const dir = dirname(file);
+	const name = basename(file, extname(file));
+	const slugs = [];
+	for (const seg of dir.split("/")) if (seg.length > 0 && !GroupRegex.test(seg)) slugs.push(encodeURI(seg));
+	if (GroupRegex.test(name)) throw new Error(`Cannot use folder group in file names: ${file}`);
+	if (name !== "index") slugs.push(encodeURI(name));
+	return slugs;
+}
+//#endregion
+export { getSlugs, slugsFromData, slugsPlugin };