fumapress 0.2.3 → 0.2.5

package/dist/layouts/root.js

@@ -0,0 +1,38 @@
+import { renderRootMeta } from "../lib/shared.js";
+import { jsx, jsxs } from "react/jsx-runtime";
+import styles from "virtual:root.css?inline";
+import { RootProvider } from "fumadocs-ui/provider/waku";
+//#region src/layouts/root.tsx
+function createRootLayout(options) {
+	return async function(props) {
+		const { children, lang, i18nConfig, data } = props;
+		const hooks = data["core:provider"];
+		let providerProps = { ...options?.providerProps };
+		if (i18nConfig) {
+			const { languages } = i18nConfig;
+			providerProps.i18n ??= {
+				locale: lang,
+				locales: Object.entries(languages).map(([k, v]) => ({
+					name: v.displayName,
+					locale: k
+				})),
+				translations: lang ? languages[lang]?.translations : void 0
+			};
+		}
+		if (hooks) for (const hook of hooks) providerProps = await hook(providerProps);
+		return /* @__PURE__ */ jsxs("html", {
+			lang: lang ?? "en",
+			suppressHydrationWarning: true,
+			children: [/* @__PURE__ */ jsxs("head", { children: [/* @__PURE__ */ jsx("style", { children: styles }), renderRootMeta(props)] }), /* @__PURE__ */ jsx("body", {
+				"data-version": "1.0",
+				className: "flex flex-col min-h-screen",
+				children: /* @__PURE__ */ jsx(RootProvider, {
+					...providerProps,
+					children
+				})
+			})]
+		});
+	};
+}
+//#endregion
+export { createRootLayout };

package/dist/lib/fs.js

@@ -0,0 +1,18 @@
+import { existsSync } from "node:fs";
+import { dirname, join } from "node:path";
+//#region src/lib/fs.ts
+/**
+* Returns the absolute path to the root directory of the current git repository.
+*/
+function getGitRootDir(startDir = process.cwd()) {
+	let dir = startDir;
+	while (true) {
+		if (existsSync(join(dir, ".git"))) return dir;
+		const parent = dirname(dir);
+		if (parent === dir) break;
+		dir = parent;
+	}
+	return null;
+}
+//#endregion
+export { getGitRootDir };

package/dist/lib/shared.d.ts

@@ -0,0 +1,46 @@
+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 { Adapter, Awaitable, ServerPlugin } from "./types.js";
+import { ComponentType, ReactNode } from "react";
+import { RootProviderProps } from "fumadocs-ui/provider/waku";
+import { LoaderOutput, Page } from "fumadocs-core/source";
+
+//#region src/lib/shared.d.ts
+interface AppContext<C extends ConfigContext = ConfigContext> {
+  mode: BuildMode;
+  getLoader: () => Awaitable<LoaderOutput<C["loaderConfig"]>>;
+  plugins: ServerPlugin<C>[];
+  adapters: Adapter<C>[];
+  /** always `undefined`, easier way to infer types */
+  $context: C;
+  /**
+   * custom data in app context, can be referenced from plugins/pages etc
+   */
+  data: AppContextData & Record<string, unknown>;
+  i18nConfig?: I18nConfig<C["lang"]>;
+  metaConfig?: Config<C>["meta"];
+  siteConfig: {
+    name: string;
+    baseUrl?: string;
+    git?: {
+      user: string;
+      repo: string;
+      branch: string;
+      rootDir: string;
+    };
+  };
+}
+interface AppContextData {
+  "core:page-meta"?: ((page: Page) => ReactNode)[];
+  "core:notebook-layout"?: NotebookLayoutContextData;
+  "core:docs-layout"?: DocsLayoutContextData;
+  "core:home-layout"?: HomeLayoutContextData;
+  "core:provider"?: ((props: RootProviderProps) => Awaitable<RootProviderProps>)[];
+}
+type TransformChildren<T> = Omit<T, "children"> & {
+  children?: ((nodes: ReactNode) => ReactNode)[];
+};
+//#endregion
+export { AppContext, AppContextData, TransformChildren };

package/dist/lib/shared.js

@@ -0,0 +1,70 @@
+import { getGitRootDir } from "./fs.js";
+import { fumadocsMdx } from "../adapters/mdx.js";
+import path from "node:path";
+import { Fragment } from "react";
+import { Fragment as Fragment$1, jsx, jsxs } from "react/jsx-runtime";
+//#region src/lib/shared.tsx
+function parseConfig(config) {
+	return {
+		getLoader() {
+			if (typeof config.loader === "function") return config.loader();
+			return config.loader;
+		},
+		plugins: config.plugins ?? [],
+		adapters: config.adapters ?? [fumadocsMdx()],
+		$context: void 0,
+		data: {},
+		i18nConfig: config.i18n,
+		mode: config.mode ?? "default",
+		metaConfig: config.meta,
+		siteConfig: {
+			name: config.site?.name ?? "Fumapress",
+			baseUrl: config.site?.baseUrl,
+			git: config.site?.git ? {
+				...config.site.git,
+				rootDir: config.site.git.rootDir ?? getGitRootDir() ?? process.cwd()
+			} : void 0
+		}
+	};
+}
+function renderRootMeta(context) {
+	return context.metaConfig?.root?.call(context);
+}
+function renderPageMeta(page, context) {
+	return /* @__PURE__ */ jsxs(Fragment$1, { children: [
+		/* @__PURE__ */ jsx("title", { children: page.data.title }),
+		/* @__PURE__ */ jsx("meta", {
+			property: "og:title",
+			content: page.data.title
+		}),
+		page.data.description && /* @__PURE__ */ jsx("meta", {
+			property: "og:description",
+			content: page.data.description
+		}),
+		context.metaConfig?.page?.call(context, page),
+		context.data["core:page-meta"]?.map((hook, i) => /* @__PURE__ */ jsx(Fragment, { children: hook(page) }, i))
+	] });
+}
+function getGitHubFileUrl(ctx, absolutePath) {
+	const { git } = ctx.siteConfig;
+	if (!git) return;
+	const p = path.relative(git.rootDir, absolutePath).replaceAll(path.sep, "/");
+	if (p.startsWith("../")) return;
+	return `https://github.com/${git.user}/${git.repo}/blob/${git.branch}/${p}`;
+}
+function baseOptions(ctx) {
+	const { name, git } = ctx.siteConfig;
+	return {
+		nav: { title: name },
+		githubUrl: git ? `https://github.com/${git.user}/${git.repo}` : void 0
+	};
+}
+function TransformChildrenSlot({ Comp, props, children }) {
+	if (props.children) for (const transformer of props.children) children = transformer(children);
+	return /* @__PURE__ */ jsx(Comp, {
+		...props,
+		children
+	});
+}
+//#endregion
+export { TransformChildrenSlot, baseOptions, getGitHubFileUrl, parseConfig, renderPageMeta, renderRootMeta };

package/dist/lib/types.d.ts

@@ -0,0 +1,33 @@
+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 { TOCItemType } from "fumadocs-core/toc";
+
+//#region src/lib/types.d.ts
+type Awaitable<T> = T | Promise<T>;
+/** allow content sources to implement interfaces for pages, instead of requiring consumers to specify manually */
+interface Adapter<C extends ConfigContext = ConfigContext> {
+  "core:get-text"?: (this: AppContext<C>, page: C["loaderConfig"]["page"]) => Awaitable<string | undefined>;
+  "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>;
+}
+interface ServerPlugin<C extends ConfigContext = ConfigContext> {
+  /** receive & modify context */
+  init?: (this: AppContext<C>) => void;
+  createPages?: (this: AppContext<C>, fns: RouteFns) => Awaitable<void>;
+}
+type RouteFns = Parameters<Parameters<typeof createPages>[0]>[0] & {
+  createApiIsomorphic: (config: {
+    render: "static" | "dynamic";
+    path: string;
+    staticPaths?: string[][];
+    handler: (req: Request, ctx: {
+      params: Record<string, string | string[]>;
+    }) => Promise<Response>;
+  }) => void;
+};
+//#endregion
+export { Adapter, Awaitable, RouteFns, ServerPlugin };

package/dist/lib/vitefu.js

@@ -0,0 +1,179 @@
+import fsSync from "node:fs";
+import path from "node:path";
+import fs from "node:fs/promises";
+import { createRequire } from "node:module";
+//#region src/lib/vitefu.ts
+let pnp;
+let pnpWorkspaceLocators = [];
+if (process.versions.pnp) try {
+	pnp = createRequire(import.meta.url)("pnpapi");
+	pnpWorkspaceLocators = pnp.getDependencyTreeRoots();
+} catch {}
+async function crawlFrameworkPkgs(options) {
+	const pkgJsonPath = await findClosestPkgJsonPath(options.root);
+	if (!pkgJsonPath) return {
+		optimizeDeps: {
+			include: [],
+			exclude: []
+		},
+		ssr: {
+			noExternal: [],
+			external: []
+		}
+	};
+	const pkgJson = await readJson(pkgJsonPath).catch((e) => {
+		throw new Error(`Unable to read ${pkgJsonPath}`, { cause: e });
+	});
+	const optimizeDepsIncludeByPkgJsonPath = /* @__PURE__ */ new Map();
+	let optimizeDepsInclude = [];
+	let optimizeDepsExclude = [];
+	let ssrNoExternal = [];
+	let ssrExternal = [];
+	await crawl(pkgJsonPath, pkgJson);
+	optimizeDepsInclude = [...optimizeDepsIncludeByPkgJsonPath.values()];
+	if (options.viteUserConfig) {
+		const userOptimizeDepsExclude = options.viteUserConfig.optimizeDeps?.exclude;
+		if (userOptimizeDepsExclude) optimizeDepsInclude = optimizeDepsInclude.filter((dep) => !isDepExcluded(dep, userOptimizeDepsExclude));
+		const userOptimizeDepsInclude = options.viteUserConfig.optimizeDeps?.include;
+		if (userOptimizeDepsInclude) optimizeDepsExclude = optimizeDepsExclude.filter((dep) => !isDepIncluded(dep, userOptimizeDepsInclude));
+		const userSsrExternal = options.viteUserConfig.ssr?.external;
+		if (userSsrExternal) ssrNoExternal = ssrNoExternal.filter((dep) => !isDepExternaled(dep, userSsrExternal));
+		const userSsrNoExternal = options.viteUserConfig.ssr?.noExternal;
+		if (userSsrNoExternal) ssrExternal = ssrExternal.filter((dep) => !isDepNoExternaled(dep, userSsrNoExternal));
+	}
+	optimizeDepsInclude.sort();
+	optimizeDepsExclude.sort();
+	ssrExternal.sort();
+	ssrNoExternal.sort();
+	return {
+		optimizeDeps: {
+			include: optimizeDepsInclude,
+			exclude: optimizeDepsExclude
+		},
+		ssr: {
+			noExternal: ssrNoExternal,
+			external: ssrExternal
+		}
+	};
+	async function crawl(currentPkgJsonPath, currentPkgJson, parentDepNames = [], parentIsFrameworkPkg = false, hasFrameworkAncestor = false) {
+		const crawlDevDependencies = parentDepNames.length === 0 || isPrivateWorkspacePackage(currentPkgJsonPath, currentPkgJson, options.workspaceRoot);
+		const deps = [...Object.keys(currentPkgJson.dependencies ?? {}), ...crawlDevDependencies ? Object.keys(currentPkgJson.devDependencies ?? {}) : []].filter((dep) => !parentDepNames.includes(dep));
+		await Promise.all(deps.map(async (dep) => {
+			const frameworkByName = options.isFrameworkPkgByName?.(dep);
+			const semiFrameworkByName = options.isSemiFrameworkPkgByName?.(dep);
+			if (frameworkByName === false || semiFrameworkByName === false) return;
+			const depPkgJsonPath = await findDepPkgJsonPath(dep, currentPkgJsonPath, !!options.workspaceRoot);
+			if (!depPkgJsonPath) return;
+			const depPkgJson = await readJson(depPkgJsonPath).catch(() => {});
+			if (!depPkgJson) return;
+			const isFrameworkPkg = frameworkByName === true || options.isFrameworkPkgByJson?.(depPkgJson) === true;
+			const isSemiFrameworkPkg = semiFrameworkByName === true || options.isSemiFrameworkPkgByJson?.(depPkgJson) === true;
+			const depChain = parentDepNames.concat(dep);
+			if (isFrameworkPkg || isSemiFrameworkPkg) {
+				if (isFrameworkPkg) {
+					pushUnique(optimizeDepsExclude, dep);
+					pushUnique(ssrNoExternal, dep);
+				} else pushUnique(ssrNoExternal, dep);
+				await crawl(depPkgJsonPath, depPkgJson, depChain, true, true);
+				return;
+			}
+			if (!hasFrameworkAncestor) return;
+			if (await pkgNeedsOptimization(depPkgJson, depPkgJsonPath)) addOptimizedDep(depPkgJsonPath, depChain);
+			else await crawl(depPkgJsonPath, depPkgJson, depChain, false, true);
+			if (!options.isBuild && parentIsFrameworkPkg) pushUnique(ssrExternal, dep);
+		}));
+	}
+	function addOptimizedDep(depPkgJsonPath, depChain) {
+		const includePath = depChain.join(" > ");
+		const current = optimizeDepsIncludeByPkgJsonPath.get(depPkgJsonPath);
+		if (!current || compareDepChains(includePath, current) < 0) optimizeDepsIncludeByPkgJsonPath.set(depPkgJsonPath, includePath);
+	}
+}
+async function findClosestPkgJsonPath(dir, predicate) {
+	let currentDir = dir.endsWith("package.json") ? path.dirname(dir) : dir;
+	while (currentDir) {
+		const pkg = path.join(currentDir, "package.json");
+		try {
+			if ((await fs.stat(pkg)).isFile() && (!predicate || await predicate(pkg))) return pkg;
+		} catch {}
+		const nextDir = path.dirname(currentDir);
+		if (nextDir === currentDir) break;
+		currentDir = nextDir;
+	}
+}
+async function pkgNeedsOptimization(pkgJson, pkgJsonPath) {
+	if (pkgJson.module || pkgJson.exports) return false;
+	if (pkgJson.main) {
+		const entryExt = path.extname(pkgJson.main);
+		return !entryExt || entryExt === ".js" || entryExt === ".cjs";
+	}
+	try {
+		await fs.access(path.join(path.dirname(pkgJsonPath), "index.js"));
+		return true;
+	} catch {
+		return false;
+	}
+}
+async function findDepPkgJsonPath(dep, parent, usePnpWorkspaceLocators) {
+	if (pnp) {
+		if (usePnpWorkspaceLocators) try {
+			const locator = pnpWorkspaceLocators.find((root) => root.name === dep);
+			if (locator) {
+				const pkgPath = pnp.getPackageInformation(locator).packageLocation;
+				return path.resolve(pkgPath, "package.json");
+			}
+		} catch {}
+		try {
+			const depRoot = pnp.resolveToUnqualified(dep, parent);
+			if (!depRoot) return;
+			return path.join(depRoot, "package.json");
+		} catch {
+			return;
+		}
+	}
+	let root = parent;
+	while (root) {
+		const pkg = path.join(root, "node_modules", dep, "package.json");
+		try {
+			await fs.access(pkg);
+			return fsSync.realpathSync(pkg);
+		} catch {}
+		const nextRoot = path.dirname(root);
+		if (nextRoot === root) break;
+		root = nextRoot;
+	}
+}
+async function readJson(pkgJsonPath) {
+	return JSON.parse(await fs.readFile(pkgJsonPath, "utf8"));
+}
+function isPrivateWorkspacePackage(pkgJsonPath, pkgJson, workspaceRoot) {
+	return !!(workspaceRoot && pkgJson.private && !pkgJsonPath.match(/[/\\]node_modules[/\\]/) && !path.relative(workspaceRoot, pkgJsonPath).startsWith(".."));
+}
+function pushUnique(array, value) {
+	if (!array.includes(value)) array.push(value);
+}
+function compareDepChains(left, right) {
+	const leftDepth = left.split(" > ").length;
+	const rightDepth = right.split(" > ").length;
+	if (leftDepth !== rightDepth) return leftDepth - rightDepth;
+	return left.localeCompare(right);
+}
+function isDepIncluded(dep, optimizeDepsInclude) {
+	return optimizeDepsInclude.some((include) => dep === include);
+}
+function isDepExcluded(dep, optimizeDepsExclude) {
+	return optimizeDepsExclude.some((exclude) => dep === exclude || dep.startsWith(`${exclude} > `));
+}
+function isDepNoExternaled(dep, ssrNoExternal) {
+	if (typeof ssrNoExternal === "boolean") return ssrNoExternal;
+	return (Array.isArray(ssrNoExternal) ? ssrNoExternal : [ssrNoExternal]).some((noExternal) => {
+		if (typeof noExternal === "string") return dep === noExternal;
+		return noExternal.test(dep);
+	});
+}
+function isDepExternaled(dep, ssrExternal) {
+	if (typeof ssrExternal === "boolean") return ssrExternal;
+	return ssrExternal.some((external) => dep === external);
+}
+//#endregion
+export { crawlFrameworkPkgs };

package/dist/plugins/flexsearch.d.ts

@@ -0,0 +1,14 @@
+import { AppContext } from "../lib/shared.js";
+import { ConfigContext } from "../config.js";
+import { Awaitable, ServerPlugin } from "../lib/types.js";
+import { Index } from "fumadocs-core/search/flexsearch";
+
+//#region src/plugins/flexsearch.d.ts
+interface FlexsearchOptions<C extends ConfigContext = ConfigContext> {
+  buildIndex?: (this: AppContext<C>, page: C["loaderConfig"]["page"]) => Awaitable<Index>;
+}
+declare function flexsearchPlugin<C extends ConfigContext = ConfigContext>({
+  buildIndex
+}?: FlexsearchOptions<NoInfer<C>>): ServerPlugin<C>;
+//#endregion
+export { FlexsearchOptions, flexsearchPlugin };

package/dist/plugins/flexsearch.js

@@ -0,0 +1,35 @@
+//#region src/plugins/flexsearch.ts
+function flexsearchPlugin({ buildIndex = async function buildIndexDefault(page) {
+	for (const adapter of this.adapters) {
+		const structuredData = await adapter["core:get-structured-data"]?.call(this, page);
+		if (structuredData !== void 0) return {
+			id: page.url,
+			title: page.data.title ?? page.path,
+			description: page.data.description,
+			url: page.url,
+			structuredData
+		};
+	}
+	throw new Error("[Fumapress] Please specify the `buildIndex` option to flexsearchPlugin()");
+} } = {}) {
+	return {
+		init() {
+			if (this.mode === "static") (this.data["core:provider"] ??= []).push(async (props) => {
+				props.search ??= {};
+				props.search.SearchDialog ??= (await import("../components/flexsearch-static.js")).default;
+				return props;
+			});
+		},
+		async createPages({ createApiIsomorphic }) {
+			const { flexsearchFromSource } = await import("fumadocs-core/search/flexsearch");
+			const server = flexsearchFromSource(this.getLoader, { buildIndex: buildIndex.bind(this) });
+			createApiIsomorphic({
+				render: this.mode === "static" ? "static" : "dynamic",
+				path: "/api/search",
+				handler: this.mode === "static" ? server.staticGET : server.GET
+			});
+		}
+	};
+}
+//#endregion
+export { flexsearchPlugin };

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

@@ -0,0 +1,11 @@
+import { AppContext } from "../lib/shared.js";
+import { ConfigContext } from "../config.js";
+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>;
+}
+declare function llmsPlugin<C extends ConfigContext = ConfigContext>(options?: LLMsOptions<NoInfer<C>>): ServerPlugin<C>;
+//#endregion
+export { LLMsOptions, llmsPlugin };

package/dist/plugins/llms.txt.js

@@ -0,0 +1,72 @@
+import { unstable_notFound } from "waku/router/server";
+import { llms } from "fumadocs-core/source/llms";
+//#region src/plugins/llms.txt.ts
+function llmsPlugin(options = {}) {
+	const { getLLMText: _getLLMText = async function getLLMTextDefault(page) {
+		for (const adapter of this.adapters) {
+			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() {
+			this.data["core:docs-layout"] ??= {};
+			this.data["core:docs-layout"].renderers ??= [];
+			this.data["core:docs-layout"].renderers.push(function(res) {
+				res.markdownUrl ??= slugsToMarkdownPath(this.page.slugs, this.page.locale).url;
+				return res;
+			});
+		},
+		async createPages({ createApiIsomorphic }) {
+			const defaultRenderMode = this.mode === "dynamic" ? "dynamic" : "static";
+			const getLLMText = _getLLMText.bind(this);
+			createApiIsomorphic({
+				render: defaultRenderMode,
+				path: "/llms.txt",
+				handler: async () => {
+					const source = await this.getLoader();
+					return new Response(llms(source).index());
+				}
+			});
+			createApiIsomorphic({
+				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"));
+				}
+			});
+			createApiIsomorphic({
+				render: defaultRenderMode,
+				path: this.i18nConfig ? "/[lang]/[...slugs]" : "/[...slugs]",
+				staticPaths: defaultRenderMode === "static" ? (await this.getLoader()).getPages().map((page) => slugsToMarkdownPath(page.slugs, page.locale).segments) : void 0,
+				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" } });
+				}
+			});
+		}
+	};
+}
+function markdownPathToSlugs(segs) {
+	const slugs = [...segs];
+	if (slugs.length === 0) return slugs;
+	slugs[slugs.length - 1] = slugs[slugs.length - 1].replace(/\.md$/, "");
+	if (slugs.length === 1 && slugs[0] === "index") slugs.pop();
+	return slugs;
+}
+function slugsToMarkdownPath(slugs, lang) {
+	const segments = [...slugs];
+	if (segments.length === 0) segments.push("index.md");
+	else segments[segments.length - 1] += ".md";
+	if (lang) segments.unshift(lang);
+	return {
+		segments,
+		url: `/${segments.join("/")}`
+	};
+}
+//#endregion
+export { llmsPlugin };

package/dist/plugins/orama-search.d.ts

@@ -0,0 +1,14 @@
+import { AppContext } from "../lib/shared.js";
+import { ConfigContext } from "../config.js";
+import { Awaitable, ServerPlugin } from "../lib/types.js";
+import { AdvancedIndex } from "fumadocs-core/search/server";
+
+//#region src/plugins/orama-search.d.ts
+interface OramaSearchOptions<C extends ConfigContext = ConfigContext> {
+  buildIndex?: (this: AppContext<C>, page: C["loaderConfig"]["page"]) => Awaitable<AdvancedIndex>;
+}
+declare function oramaSearchPlugin<C extends ConfigContext = ConfigContext>({
+  buildIndex
+}?: OramaSearchOptions<NoInfer<C>>): ServerPlugin<C>;
+//#endregion
+export { OramaSearchOptions, oramaSearchPlugin };

package/dist/plugins/orama-search.js

@@ -0,0 +1,35 @@
+//#region src/plugins/orama-search.ts
+function oramaSearchPlugin({ buildIndex = async function buildIndexDefault(page) {
+	for (const adapter of this.adapters) {
+		const structuredData = await adapter["core:get-structured-data"]?.call(this, page);
+		if (structuredData !== void 0) return {
+			id: page.url,
+			title: page.data.title ?? page.path,
+			description: page.data.description,
+			url: page.url,
+			structuredData
+		};
+	}
+	throw new Error("[Fumapress] Please specify the `buildIndex` option to oramaSearchPlugin()");
+} } = {}) {
+	return {
+		init() {
+			if (this.mode === "static") (this.data["core:provider"] ??= []).push(async (props) => {
+				props.search ??= {};
+				props.search.SearchDialog ??= (await import("../components/orama-search-static.js")).default;
+				return props;
+			});
+		},
+		async createPages({ createApiIsomorphic }) {
+			const { createFromSource } = await import("fumadocs-core/search/server");
+			const server = createFromSource(this.getLoader, { buildIndex: buildIndex.bind(this) });
+			createApiIsomorphic({
+				render: this.mode === "static" ? "static" : "dynamic",
+				path: "/api/search",
+				handler: this.mode === "static" ? server.staticGET : server.GET
+			});
+		}
+	};
+}
+//#endregion
+export { oramaSearchPlugin };

package/dist/plugins/takumi.d.ts

@@ -0,0 +1,16 @@
+import { AppContext } from "../lib/shared.js";
+import { ConfigContext } from "../config.js";
+import { Awaitable, ServerPlugin } from "../lib/types.js";
+import { ReactNode } from "react";
+import { ImageResponseOptions } from "@takumi-rs/image-response";
+
+//#region src/plugins/takumi.d.ts
+interface TakumiOptions<C extends ConfigContext = ConfigContext> {
+  generate?: (this: AppContext<C>, page: C["loaderConfig"]["page"]) => Awaitable<{
+    node: ReactNode;
+    options?: Partial<ImageResponseOptions>;
+  }>;
+}
+declare function takumiPlugin<C extends ConfigContext = ConfigContext>(options?: TakumiOptions<NoInfer<C>>): ServerPlugin<C>;
+//#endregion
+export { TakumiOptions, takumiPlugin };

package/dist/plugins/takumi.js

@@ -0,0 +1,79 @@
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { unstable_notFound } from "waku/router/server";
+import { ImageResponse } from "@takumi-rs/image-response";
+//#region src/plugins/takumi.tsx
+function takumiPlugin(options = {}) {
+	const { generate = async function generateDefault(page) {
+		const { generate } = await import("fumadocs-ui/og/takumi");
+		return { node: generate({
+			title: page.data.title,
+			description: page.data.description,
+			site: this.siteConfig.name
+		}) };
+	} } = options;
+	const width = 1200;
+	const height = 630;
+	return {
+		init() {
+			(this.data["core:page-meta"] ??= []).push((page) => {
+				const pathname = slugsToImagePath(page.slugs, page.locale).url;
+				return /* @__PURE__ */ jsxs(Fragment, { children: [
+					/* @__PURE__ */ jsx("meta", {
+						property: "og:image",
+						content: this.siteConfig.baseUrl ? new URL(pathname, this.siteConfig.baseUrl).href : pathname
+					}),
+					/* @__PURE__ */ jsx("meta", {
+						property: "og:image:width",
+						content: `${width}`
+					}),
+					/* @__PURE__ */ jsx("meta", {
+						property: "og:image:height",
+						content: `${height}`
+					}),
+					/* @__PURE__ */ jsx("meta", {
+						property: "twitter:card",
+						content: "summary_large_image"
+					})
+				] });
+			});
+		},
+		async createPages({ createApiIsomorphic }) {
+			const renderMode = this.mode === "dynamic" ? "dynamic" : "static";
+			createApiIsomorphic({
+				render: renderMode,
+				path: this.i18nConfig ? "/[lang]/[...slugs]" : "/[...slugs]",
+				staticPaths: renderMode === "static" ? (await this.getLoader()).getPages().map((page) => slugsToImagePath(page.slugs, page.locale).segments) : void 0,
+				handler: async (_, { params }) => {
+					const page = (await this.getLoader()).getPage(imagePathToSlugs(params.slugs), params.lang);
+					if (!page) unstable_notFound();
+					const { node, options } = await generate.call(this, page);
+					return new ImageResponse(node, {
+						width,
+						height,
+						...options,
+						format: "webp"
+					});
+				}
+			});
+		}
+	};
+}
+function slugsToImagePath(slugs, lang) {
+	const segments = [...slugs];
+	if (segments.length === 0) segments.push("index.webp");
+	else segments[segments.length - 1] += ".webp";
+	if (lang) segments.unshift(lang);
+	return {
+		segments,
+		url: `/${segments.join("/")}`
+	};
+}
+function imagePathToSlugs(segs) {
+	const slugs = [...segs];
+	if (slugs.length === 0) return slugs;
+	slugs[slugs.length - 1] = slugs[slugs.length - 1].replace(/\.webp$/, "");
+	if (slugs.length === 1 && slugs[0] === "index") slugs.pop();
+	return slugs;
+}
+//#endregion
+export { takumiPlugin };