fumapress 0.2.5 → 0.3.1

package/dist/layouts/switch.js

@@ -0,0 +1,21 @@
+import { jsx } from "react/jsx-runtime";
+import { unstable_notFound } from "waku/router/server";
+//#region src/layouts/switch.tsx
+function createLayoutSwitchAuto(layouts) {
+	return async function(props) {
+		const { page } = props;
+		if (!page.type) unstable_notFound();
+		const Layout = layouts[page.type];
+		if (!Layout) unstable_notFound();
+		return /* @__PURE__ */ jsx(Layout, { ...props });
+	};
+}
+function createLayoutSwitch(detector, layouts) {
+	return async function(props) {
+		const Layout = layouts[detector.call(props.ctx, props.page)];
+		if (!Layout) unstable_notFound();
+		return /* @__PURE__ */ jsx(Layout, { ...props });
+	};
+}
+//#endregion
+export { createLayoutSwitch, createLayoutSwitchAuto };

package/dist/lib/cn.js

@@ -0,0 +1,2 @@
+import { twMerge as cn } from "tailwind-merge";
+export { cn };

package/dist/lib/join-pathname.js

@@ -0,0 +1,9 @@
+//#region src/lib/join-pathname.ts
+function joinPathname(...paths) {
+	const segs = paths.join("/").split(/\/+/);
+	if (segs.length > 0 && segs[0].length === 0) segs.shift();
+	if (segs.length > 0 && segs[segs.length - 1].length === 0) segs.pop();
+	return "/" + segs.join("/");
+}
+//#endregion
+export { joinPathname };

package/dist/lib/shared/blog.js

@@ -0,0 +1,39 @@
+//#region src/lib/shared/blog.ts
+async function getTags(ctx, page) {
+	for (const adapter of ctx.adapters) {
+		const tags = await adapter["blog:get-tags"]?.call(ctx, page);
+		if (tags !== void 0) return tags;
+	}
+}
+async function groupTagsI18n(ctx, blogPosts) {
+	const localeToTags = /* @__PURE__ */ new Map();
+	for (const page of blogPosts) {
+		const tags = await getTags(ctx, page);
+		if (!tags) continue;
+		const locale = page.locale ?? "";
+		let map = localeToTags.get(locale);
+		if (!map) {
+			map = /* @__PURE__ */ new Map();
+			localeToTags.set(locale, map);
+		}
+		for (const tag of tags) {
+			const count = map.get(tag) ?? 0;
+			map.set(tag, count + 1);
+		}
+	}
+	return localeToTags;
+}
+async function groupTags(ctx, blogPosts) {
+	const map = /* @__PURE__ */ new Map();
+	for (const page of blogPosts) {
+		const tags = await getTags(ctx, page);
+		if (!tags) continue;
+		for (const tag of tags) {
+			const count = map.get(tag) ?? 0;
+			map.set(tag, count + 1);
+		}
+	}
+	return map;
+}
+//#endregion
+export { getTags, groupTags, groupTagsI18n };

package/dist/lib/shared.d.ts

@@ -1,7 +1,7 @@
 import { DocsLayoutContextData } from "../layouts/docs.js";
 import { HomeLayoutContextData } from "../layouts/home.js";
 import { NotebookLayoutContextData } from "../layouts/notebook.js";
-import { BuildMode, Config, ConfigContext, I18nConfig } from "../config.js";
+import { BuildMode, ConfigContext, I18nConfig, Layouts, MetaConfig } from "../config.js";
 import { Adapter, Awaitable, ServerPlugin } from "./types.js";
 import { ComponentType, ReactNode } from "react";
 import { RootProviderProps } from "fumadocs-ui/provider/waku";
@@ -13,6 +13,7 @@ interface AppContext<C extends ConfigContext = ConfigContext> {
   getLoader: () => Awaitable<LoaderOutput<C["loaderConfig"]>>;
   plugins: ServerPlugin<C>[];
   adapters: Adapter<C>[];
+  layouts: Partial<Layouts<C>>;
   /** always `undefined`, easier way to infer types */
   $context: C;
   /**
@@ -20,7 +21,7 @@ interface AppContext<C extends ConfigContext = ConfigContext> {
    */
   data: AppContextData & Record<string, unknown>;
   i18nConfig?: I18nConfig<C["lang"]>;
-  metaConfig?: Config<C>["meta"];
+  metaConfig?: MetaConfig<C>;
   siteConfig: {
     name: string;
     baseUrl?: string;

package/dist/lib/shared.js

@@ -1,15 +1,19 @@
+import { __toESM } from "../_virtual/_rolldown/runtime.js";
 import { getGitRootDir } from "./fs.js";
 import { fumadocsMdx } from "../adapters/mdx.js";
+import { require_deepmerge } from "../node_modules/.pnpm/@fastify_deepmerge@3.2.1/node_modules/@fastify/deepmerge/index.js";
 import path from "node:path";
-import { Fragment } from "react";
+import { Fragment, isValidElement } from "react";
 import { Fragment as Fragment$1, jsx, jsxs } from "react/jsx-runtime";
 //#region src/lib/shared.tsx
+var import_deepmerge = /* @__PURE__ */ __toESM(require_deepmerge());
 function parseConfig(config) {
 	return {
 		getLoader() {
 			if (typeof config.loader === "function") return config.loader();
 			return config.loader;
 		},
+		layouts: config.layouts ?? {},
 		plugins: config.plugins ?? [],
 		adapters: config.adapters ?? [fumadocsMdx()],
 		$context: void 0,
@@ -52,19 +56,54 @@ function getGitHubFileUrl(ctx, absolutePath) {
 	if (p.startsWith("../")) return;
 	return `https://github.com/${git.user}/${git.repo}/blob/${git.branch}/${p}`;
 }
-function baseOptions(ctx) {
+function baseLayoutProps(ctx) {
 	const { name, git } = ctx.siteConfig;
 	return {
-		nav: { title: name },
-		githubUrl: git ? `https://github.com/${git.user}/${git.repo}` : void 0
+		githubUrl: git ? `https://github.com/${git.user}/${git.repo}` : void 0,
+		nav: { title: name }
 	};
 }
-function TransformChildrenSlot({ Comp, props, children }) {
-	if (props.children) for (const transformer of props.children) children = transformer(children);
-	return /* @__PURE__ */ jsx(Comp, {
-		...props,
-		children
-	});
+function createTransformChildren(Component) {
+	return function({ props, children }) {
+		if (props.children) for (const transformer of props.children) children = transformer(children);
+		return /* @__PURE__ */ jsx(Component, {
+			...props,
+			children
+		});
+	};
+}
+async function renderBody(ctx, page, errorMessage) {
+	for (const adapter of ctx.adapters) {
+		const body = await adapter["core:render-body"]?.call(ctx, page);
+		if (body !== void 0) return body;
+	}
+	throw new Error(errorMessage);
+}
+async function renderToc(ctx, page) {
+	for (const adapter of ctx.adapters) {
+		const toc = await adapter["core:render-toc"]?.call(ctx, page);
+		if (toc !== void 0) return toc;
+	}
+}
+async function getCreationDate(ctx, page) {
+	for (const adapter of ctx.adapters) {
+		const date = await adapter["core:get-creation-date"]?.call(ctx, page);
+		if (date !== void 0) return date;
+	}
+}
+async function getLastModifiedDate(ctx, page) {
+	for (const adapter of ctx.adapters) {
+		const date = await adapter["core:get-modified-date"]?.call(ctx, page);
+		if (date !== void 0) return date;
+	}
 }
+const mergeLayoutConfigs = (0, import_deepmerge.default)({
+	all: true,
+	onlyDefinedProperties: true,
+	isMergeableObject(value) {
+		if (isValidElement(value)) return false;
+		return import_deepmerge.default.isMergeableObject(value);
+	}
+});
 //#endregion
-export { TransformChildrenSlot, baseOptions, getGitHubFileUrl, parseConfig, renderPageMeta, renderRootMeta };
+export { baseLayoutProps, createTransformChildren, getCreationDate, getGitHubFileUrl, getLastModifiedDate, mergeLayoutConfigs, parseConfig, renderBody, renderPageMeta, renderRootMeta, renderToc };

package/dist/lib/types.d.ts

@@ -1,9 +1,9 @@
 import { AppContext } from "./shared.js";
 import { ConfigContext } from "../config.js";
-import { createPages } from "waku";
 import { ReactNode } from "react";
-import { StructuredData } from "fumadocs-core/mdx-plugins";
+import { CreateApi, CreateLayout, CreatePage, CreateRoot, CreateSlice } from "waku/router/server";
 import { TOCItemType } from "fumadocs-core/toc";
+import { StructuredData } from "fumadocs-core/mdx-plugins";
 
 //#region src/lib/types.d.ts
 type Awaitable<T> = T | Promise<T>;
@@ -13,13 +13,27 @@ interface Adapter<C extends ConfigContext = ConfigContext> {
   "core:get-structured-data"?: (this: AppContext<C>, page: C["loaderConfig"]["page"]) => Awaitable<StructuredData | undefined>;
   "core:render-body"?: (this: AppContext<C>, page: C["loaderConfig"]["page"]) => Awaitable<ReactNode>;
   "core:render-toc"?: (this: AppContext<C>, page: C["loaderConfig"]["page"]) => Awaitable<TOCItemType[] | undefined>;
+  "core:get-creation-date"?: (this: AppContext<C>, page: C["loaderConfig"]["page"]) => Awaitable<Date | undefined>;
+  "core:get-modified-date"?: (this: AppContext<C>, page: C["loaderConfig"]["page"]) => Awaitable<Date | undefined>;
+  "blog:get-tags"?: (this: AppContext<C>, page: C["loaderConfig"]["page"]) => Awaitable<string[] | undefined>;
+}
+interface CreatePagesContext<C extends ConfigContext = ConfigContext> extends AppContext<C> {
+  /** call this function if the page's route is already created by your plugin */
+  markResolved: (page: C["loaderConfig"]["page"]) => void;
 }
 interface ServerPlugin<C extends ConfigContext = ConfigContext> {
   /** receive & modify context */
-  init?: (this: AppContext<C>) => void;
-  createPages?: (this: AppContext<C>, fns: RouteFns) => Awaitable<void>;
+  init?: (this: AppContext<C>) => Awaitable<void>;
+  createPages?: (this: CreatePagesContext<C>, fns: RouteFns) => Awaitable<void>;
 }
-type RouteFns = Parameters<Parameters<typeof createPages>[0]>[0] & {
+interface BaseRouteFns {
+  createPage: CreatePage;
+  createLayout: CreateLayout;
+  createRoot: CreateRoot;
+  createApi: CreateApi;
+  createSlice: CreateSlice;
+}
+interface RouteFns extends BaseRouteFns {
   createApiIsomorphic: (config: {
     render: "static" | "dynamic";
     path: string;
@@ -28,6 +42,6 @@ type RouteFns = Parameters<Parameters<typeof createPages>[0]>[0] & {
       params: Record<string, string | string[]>;
     }) => Promise<Response>;
   }) => void;
-};
+}
 //#endregion
 export { Adapter, Awaitable, RouteFns, ServerPlugin };

package/dist/node_modules/.pnpm/@fastify_deepmerge@3.2.1/node_modules/@fastify/deepmerge/index.js

@@ -0,0 +1,108 @@
+import { __commonJSMin } from "../../../../../../_virtual/_rolldown/runtime.js";
+//#region ../../node_modules/.pnpm/@fastify+deepmerge@3.2.1/node_modules/@fastify/deepmerge/index.js
+var require_deepmerge = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const JSON_PROTO = Object.getPrototypeOf({});
+	function defaultIsMergeableObjectFactory() {
+		return function defaultIsMergeableObject(value) {
+			return typeof value === "object" && value !== null && !(value instanceof RegExp) && !(value instanceof Date);
+		};
+	}
+	function deepmergeConstructor(options) {
+		function isNotPrototypeKey(value) {
+			return value !== "constructor" && value !== "prototype" && value !== "__proto__";
+		}
+		function cloneArray(value) {
+			let i = 0;
+			const il = value.length;
+			const result = new Array(il);
+			for (; i < il; ++i) result[i] = clone(value[i]);
+			return result;
+		}
+		function cloneObject(target) {
+			const result = {};
+			if (cloneProtoObject && Object.getPrototypeOf(target) !== JSON_PROTO) return cloneProtoObject(target);
+			const targetKeys = getKeys(target);
+			let i, il, key;
+			for (i = 0, il = targetKeys.length; i < il; ++i) isNotPrototypeKey(key = targetKeys[i]) && (result[key] = clone(target[key]));
+			return result;
+		}
+		function concatArrays(target, source) {
+			const tl = target.length;
+			const sl = source.length;
+			let i = 0;
+			const result = new Array(tl + sl);
+			for (; i < tl; ++i) result[i] = clone(target[i]);
+			for (i = 0; i < sl; ++i) result[i + tl] = clone(source[i]);
+			return result;
+		}
+		const propertyIsEnumerable = Object.prototype.propertyIsEnumerable;
+		function getSymbolsAndKeys(value) {
+			const result = Object.keys(value);
+			const keys = Object.getOwnPropertySymbols(value);
+			for (let i = 0, il = keys.length; i < il; ++i) propertyIsEnumerable.call(value, keys[i]) && result.push(keys[i]);
+			return result;
+		}
+		const getKeys = options?.symbols ? getSymbolsAndKeys : Object.keys;
+		const cloneProtoObject = typeof options?.cloneProtoObject === "function" ? options.cloneProtoObject : void 0;
+		const isMergeableObject = typeof options?.isMergeableObject === "function" ? options.isMergeableObject : defaultIsMergeableObjectFactory();
+		const onlyDefinedProperties = options?.onlyDefinedProperties === true;
+		function isPrimitive(value) {
+			return typeof value !== "object" || value === null;
+		}
+		const mergeArray = options && typeof options.mergeArray === "function" ? options.mergeArray({
+			clone,
+			deepmerge: _deepmerge,
+			getKeys,
+			isMergeableObject
+		}) : concatArrays;
+		function clone(entry) {
+			return isMergeableObject(entry) ? Array.isArray(entry) ? cloneArray(entry) : cloneObject(entry) : entry;
+		}
+		function mergeObject(target, source) {
+			const result = {};
+			const targetKeys = getKeys(target);
+			const sourceKeys = getKeys(source);
+			let i, il, key;
+			for (i = 0, il = targetKeys.length; i < il; ++i) isNotPrototypeKey(key = targetKeys[i]) && sourceKeys.indexOf(key) === -1 && (result[key] = clone(target[key]));
+			for (i = 0, il = sourceKeys.length; i < il; ++i) {
+				if (!isNotPrototypeKey(key = sourceKeys[i])) continue;
+				if (key in target) {
+					if (targetKeys.indexOf(key) !== -1) if (cloneProtoObject && isMergeableObject(source[key]) && Object.getPrototypeOf(source[key]) !== JSON_PROTO) result[key] = cloneProtoObject(source[key]);
+					else result[key] = _deepmerge(target[key], source[key]);
+				} else {
+					if (onlyDefinedProperties && typeof source[key] === "undefined") continue;
+					result[key] = clone(source[key]);
+				}
+			}
+			return result;
+		}
+		function _deepmerge(target, source) {
+			if (onlyDefinedProperties && typeof source === "undefined") return clone(target);
+			const sourceIsArray = Array.isArray(source);
+			const targetIsArray = Array.isArray(target);
+			if (isPrimitive(source)) return source;
+			else if (!isMergeableObject(target)) return clone(source);
+			else if (sourceIsArray && targetIsArray) return mergeArray(target, source);
+			else if (sourceIsArray !== targetIsArray) return clone(source);
+			else return mergeObject(target, source);
+		}
+		function _deepmergeAll() {
+			switch (arguments.length) {
+				case 0: return {};
+				case 1: return clone(arguments[0]);
+				case 2: return _deepmerge(arguments[0], arguments[1]);
+			}
+			let result;
+			for (let i = 0, il = arguments.length; i < il; ++i) result = _deepmerge(result, arguments[i]);
+			return result;
+		}
+		return options?.all ? _deepmergeAll : _deepmerge;
+	}
+	module.exports = deepmergeConstructor;
+	module.exports.default = deepmergeConstructor;
+	module.exports.deepmerge = deepmergeConstructor;
+	Object.defineProperty(module.exports, "isMergeableObject", { get: defaultIsMergeableObjectFactory });
+}));
+//#endregion
+export default require_deepmerge();
+export { require_deepmerge };

package/dist/plugins/blog.d.ts

@@ -0,0 +1,72 @@
+import { AppContext } from "../lib/shared.js";
+import { ConfigContext } from "../config.js";
+import { ServerPlugin } from "../lib/types.js";
+import { ComponentType, ReactNode } from "react";
+
+//#region src/plugins/blog.d.ts
+interface BlogPluginOptions<C extends ConfigContext = ConfigContext> {
+  /** default to checking from `page.type` */
+  isBlog?: (this: AppContext<C>, page: C["loaderConfig"]["page"]) => boolean;
+  paths?: {
+    /**
+     * pathname for index page
+     *
+     * @default "/blog"
+     */
+    index?: string | false;
+    /**
+     * pathname for tags page
+     *
+     * @default "/blog/tags"
+     */
+    tags?: string | false;
+  };
+  layouts?: {
+    /** shared layout for blog */layout?: BlogLayout<C>; /** renderer of blog posts (displayed inside `layout`) */
+    page?: BlogLayoutPage<C>; /** renderer of index page (displayed inside `layout`) */
+    index?: BlogIndexPage<C>; /** renderer of tags page (displayed inside `layout`) */
+    tags?: BlogTagsPage<C>; /** renderer of tag page (displayed inside `layout`) */
+    tag?: BlogTagPage<C>;
+  };
+}
+interface BlogContext<C extends ConfigContext> {
+  indexPath: string | false;
+  tagsPath: string | false;
+  isBlog: (this: AppContext<C>, page: C["loaderConfig"]["page"]) => boolean;
+}
+type BlogLayoutPage<C extends ConfigContext = ConfigContext> = ComponentType<{
+  lang?: string;
+  slugs: string[];
+  page: C["loaderConfig"]["page"];
+  blog: BlogContext<C>;
+  ctx: AppContext<C>;
+}>;
+type BlogLayout<C extends ConfigContext = ConfigContext> = ComponentType<{
+  lang?: string;
+  children: ReactNode;
+  blog: BlogContext<C>;
+  ctx: AppContext<C>;
+}>;
+type BlogIndexPage<C extends ConfigContext = ConfigContext> = ComponentType<{
+  lang?: string;
+  blog: BlogContext<C>;
+  ctx: AppContext<C>;
+}>;
+type BlogTagsPage<C extends ConfigContext = ConfigContext> = ComponentType<{
+  lang?: string;
+  blog: BlogContext<C>;
+  ctx: AppContext<C>;
+}>;
+type BlogTagPage<C extends ConfigContext = ConfigContext> = ComponentType<{
+  lang?: string;
+  tag: string;
+  blog: BlogContext<C>;
+  ctx: AppContext<C>;
+}>;
+declare function blogPlugin<C extends ConfigContext = ConfigContext>({
+  paths,
+  isBlog,
+  layouts
+}?: BlogPluginOptions<C>): ServerPlugin<C>;
+//#endregion
+export { BlogContext, BlogIndexPage, BlogLayout, BlogLayoutPage, BlogPluginOptions, BlogTagPage, BlogTagsPage, blogPlugin };

package/dist/plugins/blog.js

@@ -0,0 +1,175 @@
+import { joinPathname } from "../lib/join-pathname.js";
+import { createBlogIndexPage } from "../layouts/blog.index.js";
+import { groupTags, groupTagsI18n } from "../lib/shared/blog.js";
+import { createBlogTagPage, createBlogTagsPage } from "../layouts/blog.tags.js";
+import { createBlogLayout, createBlogLayoutPage } from "../layouts/blog.js";
+import { jsx } from "react/jsx-runtime";
+import { unstable_notFound } from "waku/router/server";
+//#region src/plugins/blog.tsx
+function blogPlugin({ paths = {}, isBlog = (page) => page.type === "blog", layouts = {} } = {}) {
+	const blogCtx = {
+		indexPath: paths.index ?? "/blog",
+		tagsPath: paths.tags ?? "/blog/tags",
+		isBlog
+	};
+	return { async createPages({ createPage, createLayout }) {
+		const renderMode = this.mode === "dynamic" ? "dynamic" : "static";
+		const source = await this.getLoader();
+		const blogPages = [];
+		for (const page of source.getPages()) {
+			if (!isBlog.call(this, page)) continue;
+			blogPages.push(page);
+			this.markResolved(page);
+		}
+		const Layout = layouts.layout ?? createBlogLayout();
+		const Page = layouts.page ?? createBlogLayoutPage();
+		if (this.i18nConfig) {
+			createLayout({
+				render: renderMode,
+				path: "/[lang]/(blog)",
+				component: ({ lang, children }) => {
+					return /* @__PURE__ */ jsx(Layout, {
+						lang,
+						blog: blogCtx,
+						ctx: this,
+						children
+					});
+				}
+			});
+			createPage({
+				render: renderMode,
+				path: "/[lang]/(blog)/[...slugs]",
+				staticPaths: blogPages.map((page) => [page.locale, ...page.slugs]),
+				component: async ({ slugs, lang }) => {
+					const page = (await this.getLoader()).getPage(slugs, lang);
+					if (!page || !isBlog.call(this, page)) unstable_notFound();
+					return /* @__PURE__ */ jsx(Page, {
+						lang,
+						slugs,
+						blog: blogCtx,
+						page,
+						ctx: this
+					});
+				}
+			});
+			if (blogCtx.indexPath !== false) {
+				const IndexPage = layouts.index ?? createBlogIndexPage();
+				createPage({
+					render: renderMode,
+					path: joinPathname("/[lang]/(blog)", blogCtx.indexPath),
+					staticPaths: Object.keys(this.i18nConfig.languages),
+					component: ({ lang }) => {
+						return /* @__PURE__ */ jsx(IndexPage, {
+							lang,
+							blog: blogCtx,
+							ctx: this
+						});
+					}
+				});
+			}
+			if (blogCtx.tagsPath !== false) {
+				const TagsPage = layouts.tags ?? createBlogTagsPage();
+				const TagPage = layouts.tag ?? createBlogTagPage();
+				createPage({
+					path: joinPathname("/[lang]/(blog)", blogCtx.tagsPath),
+					render: renderMode,
+					staticPaths: Object.keys(this.i18nConfig.languages),
+					component: ({ lang }) => {
+						return /* @__PURE__ */ jsx(TagsPage, {
+							lang,
+							blog: blogCtx,
+							ctx: this
+						});
+					}
+				});
+				const groupedTags = await groupTagsI18n(this, blogPages);
+				const staticPaths = [];
+				for (const [locale, tags] of groupedTags) for (const tag of tags.keys()) staticPaths.push([locale, tag]);
+				createPage({
+					path: joinPathname("/[lang]/(blog)", blogCtx.tagsPath, "[tag]"),
+					render: renderMode,
+					staticPaths,
+					component: ({ lang, tag }) => {
+						return /* @__PURE__ */ jsx(TagPage, {
+							lang,
+							tag,
+							blog: blogCtx,
+							ctx: this
+						});
+					}
+				});
+			}
+		} else {
+			createLayout({
+				render: renderMode,
+				path: "/(blog)",
+				component: ({ children }) => {
+					return /* @__PURE__ */ jsx(Layout, {
+						blog: blogCtx,
+						ctx: this,
+						children
+					});
+				}
+			});
+			createPage({
+				render: renderMode,
+				path: "/(blog)/[...slugs]",
+				staticPaths: blogPages.map((page) => page.slugs),
+				component: async ({ slugs }) => {
+					const page = (await this.getLoader()).getPage(slugs);
+					if (!page || !isBlog.call(this, page)) unstable_notFound();
+					return /* @__PURE__ */ jsx(Page, {
+						blog: blogCtx,
+						slugs,
+						page,
+						ctx: this
+					});
+				}
+			});
+			if (blogCtx.indexPath !== false) {
+				const IndexPage = layouts.index ?? createBlogIndexPage();
+				createPage({
+					render: renderMode,
+					path: joinPathname("/(blog)", blogCtx.indexPath),
+					staticPaths: [],
+					component: () => {
+						return /* @__PURE__ */ jsx(IndexPage, {
+							blog: blogCtx,
+							ctx: this
+						});
+					}
+				});
+			}
+			if (blogCtx.tagsPath !== false) {
+				const TagsPage = layouts.tags ?? createBlogTagsPage();
+				const TagPage = layouts.tag ?? createBlogTagPage();
+				createPage({
+					path: joinPathname("/(blog)", blogCtx.tagsPath),
+					render: renderMode,
+					staticPaths: [],
+					component: () => {
+						return /* @__PURE__ */ jsx(TagsPage, {
+							blog: blogCtx,
+							ctx: this
+						});
+					}
+				});
+				const grouped = await groupTags(this, blogPages);
+				createPage({
+					path: joinPathname("/(blog)", blogCtx.tagsPath, "[tag]"),
+					render: renderMode,
+					staticPaths: Array.from(grouped.keys()),
+					component: ({ tag }) => {
+						return /* @__PURE__ */ jsx(TagPage, {
+							tag,
+							blog: blogCtx,
+							ctx: this
+						});
+					}
+				});
+			}
+		}
+	} };
+}
+//#endregion
+export { blogPlugin };

package/dist/plugins/llms.txt.d.ts

@@ -4,7 +4,7 @@ import { Awaitable, ServerPlugin } from "../lib/types.js";
 
 //#region src/plugins/llms.txt.d.ts
 interface LLMsOptions<C extends ConfigContext = ConfigContext> {
-  getLLMText?: (this: AppContext<C>, page: C["loaderConfig"]["page"]) => Awaitable<string>;
+  getLLMText?: (this: AppContext<C>, page: C["loaderConfig"]["page"]) => Awaitable<string | undefined>;
 }
 declare function llmsPlugin<C extends ConfigContext = ConfigContext>(options?: LLMsOptions<NoInfer<C>>): ServerPlugin<C>;
 //#endregion

package/dist/plugins/llms.txt.js

@@ -7,7 +7,6 @@ function llmsPlugin(options = {}) {
 			const txt = await adapter["core:get-text"]?.call(this, page);
 			if (txt !== void 0) return `# ${page.data.title} (${page.url})\n\n${txt}`;
 		}
-		throw new Error("[Fumapress] Please specify the `getLLMText()` option in llmsPlugin()");
 	} } = options;
 	return {
 		init() {
@@ -33,9 +32,9 @@ function llmsPlugin(options = {}) {
 				render: defaultRenderMode,
 				path: "/llms-full.txt",
 				handler: async () => {
-					const scan = (await this.getLoader()).getPages().map(getLLMText);
-					const scanned = await Promise.all(scan);
-					return new Response(scanned.join("\n\n"));
+					const source = await this.getLoader();
+					const scanned = await Promise.all(source.getPages().map(getLLMText));
+					return new Response(scanned.filter((item) => item !== void 0).join("\n\n"));
 				}
 			});
 			createApiIsomorphic({
@@ -45,7 +44,8 @@ function llmsPlugin(options = {}) {
 				handler: async (_req, { params }) => {
 					const page = (await this.getLoader()).getPage(markdownPathToSlugs(params.slugs), params.lang);
 					if (!page) unstable_notFound();
-					return new Response(await getLLMText(page), { headers: { "Content-Type": "text/markdown" } });
+					const txt = await getLLMText(page);
+					return new Response(txt ?? "", { headers: { "Content-Type": "text/markdown" } });
 				}
 			});
 		}

package/dist/plugins/openapi.d.ts

@@ -0,0 +1,13 @@
+import { ConfigContext } from "../config.js";
+import { ServerPlugin } from "../lib/types.js";
+import { OpenAPIAdapterOptions } from "../adapters/openapi.js";
+import { openapiPlugin as openapiLoaderPlugin } from "fumadocs-openapi/server";
+
+//#region src/plugins/openapi.d.ts
+type OpenAPIOptions = OpenAPIAdapterOptions;
+/**
+ * this will register the OpenAPI adapter & required layout configs.
+ */
+declare function openapiPlugin<C extends ConfigContext>(options: OpenAPIOptions): ServerPlugin<C>;
+//#endregion
+export { OpenAPIOptions, openapiLoaderPlugin, openapiPlugin };

package/dist/plugins/openapi.js

@@ -0,0 +1,21 @@
+import { fumadocsOpenAPI, isOpenAPI } from "../adapters/openapi.js";
+import { openapiPlugin as openapiLoaderPlugin } from "fumadocs-openapi/server";
+//#region src/plugins/openapi.tsx
+/**
+* this will register the OpenAPI adapter & required layout configs.
+*/
+function openapiPlugin(options) {
+	function initRenderers(data) {
+		(data.renderers ??= []).push(function(data) {
+			if (isOpenAPI(this.page.data)) data.pageProps.full ??= true;
+			return data;
+		});
+	}
+	return { init() {
+		this.adapters.push(fumadocsOpenAPI(options));
+		initRenderers(this.data["core:docs-layout"] ??= {});
+		initRenderers(this.data["core:notebook-layout"] ??= {});
+	} };
+}
+//#endregion
+export { openapiLoaderPlugin, openapiPlugin };