create-fumadocs-app 16.0.1 → 16.0.3

package/dist/orama-cloud-VQUOOEZ2.js

@@ -0,0 +1,313 @@
+import {
+  copy,
+  depVersions,
+  pick,
+  sourceDir,
+  writeFile
+} from "./chunk-HLHY7KAF.js";
+
+// src/plugins/orama-cloud.ts
+import path from "path";
+import fs2 from "fs/promises";
+
+// src/transform/shared.ts
+import { IndentationText, Project, QuoteKind } from "ts-morph";
+import fs from "fs/promises";
+var project = new Project({
+  manipulationSettings: {
+    indentationText: IndentationText.TwoSpaces,
+    quoteKind: QuoteKind.Single
+  }
+});
+async function createSourceFile(path2) {
+  return project.createSourceFile(path2, (await fs.readFile(path2)).toString(), {
+    overwrite: true
+  });
+}
+function getCodeValue(v) {
+  return new Function(`return ${v}`)();
+}
+
+// src/transform/tanstack-start.ts
+import { SyntaxKind } from "ts-morph";
+function addTanstackPrerender(sourceFile, paths) {
+  const optionsArg = getTanstackStartCall(sourceFile)?.getArguments()[0]?.asKind(SyntaxKind.ObjectLiteralExpression);
+  if (!optionsArg) {
+    return;
+  }
+  const pagesProperty = optionsArg.getProperty("pages")?.asKind(SyntaxKind.PropertyAssignment);
+  if (pagesProperty) {
+    const initializer = pagesProperty.getInitializerIfKindOrThrow(
+      SyntaxKind.ArrayLiteralExpression
+    );
+    const existingPaths = /* @__PURE__ */ new Set();
+    for (const element of initializer.getElements()) {
+      const value = element.asKind(SyntaxKind.ObjectLiteralExpression)?.getProperty("path")?.asKind(SyntaxKind.PropertyAssignment)?.getInitializer()?.getText();
+      if (value) {
+        existingPaths.add(getCodeValue(value));
+      }
+    }
+    for (const path2 of paths) {
+      if (existingPaths.has(path2)) continue;
+      initializer.addElement(toItem(path2));
+    }
+  } else {
+    optionsArg.addProperty(
+      `pages: [
+${paths.map((path2) => `  ${toItem(path2)}`).join(",\n")}
+]`
+    );
+  }
+}
+function toItem(path2) {
+  return `{ path: '${path2}' }`;
+}
+function getTanstackStartCall(sourceFile) {
+  const pluginsProperty = sourceFile.getDefaultExportSymbol()?.getValueDeclaration()?.getFirstDescendantByKind(SyntaxKind.ObjectLiteralExpression)?.getProperty("plugins")?.getFirstChildByKind(SyntaxKind.ArrayLiteralExpression);
+  if (!pluginsProperty) return;
+  for (const element of pluginsProperty.getElements()) {
+    const expression = element.asKind(SyntaxKind.CallExpression);
+    if (expression && expression.getFirstChildByKind(SyntaxKind.Identifier)?.getText() === "tanstackStart") {
+      return expression;
+    }
+  }
+}
+
+// src/transform/react-router.ts
+import {
+  ts
+} from "ts-morph";
+var SyntaxKind2 = ts.SyntaxKind;
+function removeReactRouterPrerenderExclude(sourceFile, paths) {
+  const methodBody = getPrerenderMethod(sourceFile)?.getBody();
+  if (!methodBody) return;
+  const initializer = methodBody.getDescendantsOfKind(SyntaxKind2.VariableDeclaration).find((item) => item.getName() === "excluded")?.getInitializerIfKind(SyntaxKind2.ArrayLiteralExpression);
+  if (!initializer) return;
+  for (const element of initializer.getElements()) {
+    const value = getCodeValue(element.getText());
+    if (paths.includes(value)) {
+      initializer.removeElement(element);
+    }
+  }
+}
+function addReactRouterRoute(sourceFile, routes) {
+  modifyReactRouterRoutes(sourceFile, (arr) => {
+    for (const { path: path2, entry } of routes) {
+      arr.addElement(`route('${path2}', '${entry}')`);
+    }
+  });
+}
+function filterReactRouterRoute(sourceFile, filter) {
+  modifyReactRouterRoutes(sourceFile, (arr) => {
+    for (const element of arr.getElements()) {
+      if (!element.isKind(SyntaxKind2.CallExpression) || element.getFirstChildByKind(SyntaxKind2.Identifier)?.getText() !== "route" || filter({
+        path: getCodeValue(element.getArguments()[0].getText())
+      }))
+        continue;
+      arr.removeElement(element);
+    }
+  });
+}
+function modifyReactRouterRoutes(sourceFile, mod) {
+  const initializer = sourceFile.getDefaultExportSymbol()?.getValueDeclaration()?.getFirstDescendantByKind(SyntaxKind2.ArrayLiteralExpression);
+  if (initializer) mod(initializer);
+}
+function getPrerenderMethod(sourceFile) {
+  return sourceFile.getDefaultExportSymbol()?.getValueDeclaration()?.getFirstDescendantByKind(SyntaxKind2.ObjectLiteralExpression)?.getProperty("prerender")?.asKind(SyntaxKind2.MethodDeclaration) ?? null;
+}
+
+// src/transform/provider.ts
+import { StructureKind, SyntaxKind as SyntaxKind3 } from "ts-morph";
+function addSearchDialog(sourceFile) {
+  const elements = sourceFile.getDescendantsOfKind(SyntaxKind3.JsxElement);
+  for (const element of elements) {
+    const provider = element.getFirstChildByKind(SyntaxKind3.JsxOpeningElement);
+    if (provider?.getTagNameNode().getText() !== "RootProvider") continue;
+    if (provider.getAttributes().some(
+      (attr) => attr.isKind(SyntaxKind3.JsxAttribute) && attr.getNameNode().getText() === "search"
+    ))
+      continue;
+    provider.addAttribute({
+      kind: StructureKind.JsxAttribute,
+      name: "search",
+      initializer: "{{ SearchDialog }}"
+    });
+  }
+  sourceFile.addImportDeclaration({
+    moduleSpecifier: "@/components/search",
+    defaultImport: "SearchDialog"
+  });
+}
+
+// src/plugins/orama-cloud.ts
+function oramaCloud() {
+  return {
+    packageJson(packageJson) {
+      return {
+        ...packageJson,
+        scripts: {
+          ...packageJson.scripts,
+          build: `${packageJson.scripts.build} && bun scripts/sync-content.ts`
+        },
+        dependencies: {
+          ...packageJson.dependencies,
+          ...pick(depVersions, ["@orama/core"])
+        }
+      };
+    },
+    readme(content) {
+      return `${content}
+
+## Orama Cloud
+    
+This project uses Orama Cloud for 3rd party search solution.
+
+See https://fumadocs.dev/docs/headless/search/orama-cloud for integrating Orama Cloud to Fumadocs.`;
+    },
+    async afterWrite() {
+      const { dest, template, options } = this;
+      const appDir = path.join(dest, options.useSrcDir ? "src" : ".");
+      await copy(path.join(sourceDir, "template/+orama-cloud/@root"), dest);
+      await copy(path.join(sourceDir, "template/+orama-cloud/@app"), appDir);
+      if (template.value === "tanstack-start") {
+        await Promise.all([
+          fluent(
+            createSourceFile(path.join(dest, "vite.config.ts")),
+            (file) => addTanstackPrerender(file, ["/static.json"]),
+            (file) => file.save()
+          ),
+          fs2.unlink(path.join(dest, "src/routes/api/search.ts")).catch(() => null),
+          writeFile(
+            path.join(dest, "src/routes/static[.]json.ts"),
+            route.tanstack
+          ),
+          updateRootProvider(path.join(dest, "src/routes/__root.tsx"))
+        ]);
+      } else if (template.value.startsWith("react-router")) {
+        await Promise.all([
+          fluent(
+            createSourceFile(path.join(dest, "app/routes.ts")),
+            (file) => filterReactRouterRoute(file, ({ path: path2 }) => path2 !== "api/search"),
+            (file) => addReactRouterRoute(file, [
+              {
+                path: "static.json",
+                entry: "routes/static.ts"
+              }
+            ]),
+            (file) => file.save()
+          ),
+          fluent(
+            createSourceFile(path.join(dest, "react-router.config.ts")),
+            (file) => removeReactRouterPrerenderExclude(file, ["/api/search"]),
+            (file) => file.save()
+          ),
+          fs2.unlink(path.join(dest, "app/docs/search.ts")).catch(() => null),
+          writeFile(
+            path.join(dest, "app/routes/static.ts"),
+            route["react-router"]
+          ),
+          updateRootProvider(path.join(dest, "app/root.tsx"))
+        ]);
+      } else if (template.value.startsWith("+next")) {
+        await Promise.all([
+          fs2.unlink(path.join(appDir, "app/api/search/route.ts")).catch(() => null),
+          writeFile(path.join(appDir, "app/static.json/route.ts"), route.next),
+          updateRootProvider(path.join(appDir, "app/layout.tsx"))
+        ]);
+      } else {
+        await Promise.all([
+          fs2.unlink(path.join(dest, "src/pages/api/search.ts")).catch(() => null),
+          writeFile(
+            path.join(dest, "src/pages/api/static.json.ts"),
+            route.waku
+          ),
+          updateRootProvider(path.join(dest, "src/components/provider.tsx"))
+        ]);
+      }
+      const filePath = {
+        "+next+fuma-docs-mdx": ".next/server/app/static.json.body",
+        "tanstack-start": ".output/public/static.json",
+        "react-router": "build/client/static.json",
+        "react-router-spa": "build/client/static.json",
+        waku: "dist/public/static.json"
+      }[template.value];
+      await writeFile(
+        path.join(dest, "scripts/sync-content.ts"),
+        `import { type OramaDocument, sync } from 'fumadocs-core/search/orama-cloud';
+import * as fs from 'node:fs/promises';
+import { OramaCloud } from '@orama/core';
+
+// the path of pre-rendered \`static.json\`
+const filePath = '${filePath}';
+
+async function main() {
+  const orama = new OramaCloud({
+    projectId: process.env.NEXT_PUBLIC_ORAMA_PROJECT_ID,
+    apiKey: process.env.ORAMA_PRIVATE_API_KEY,
+  });
+
+  const content = await fs.readFile(filePath);
+  const records = JSON.parse(content.toString()) as OramaDocument[];
+
+  await sync(orama, {
+    index: process.env.NEXT_PUBLIC_ORAMA_DATASOURCE_ID,
+    documents: records,
+  });
+
+  console.log(\`search updated: \${records.length} records\`);
+}
+
+void main();`
+      );
+    }
+  };
+}
+async function updateRootProvider(rootPath) {
+  await fluent(
+    createSourceFile(rootPath),
+    (file) => addSearchDialog(file),
+    (file) => file.save()
+  );
+}
+async function fluent(value, ...actions) {
+  for (const action of actions) {
+    await action(await value);
+  }
+  return value;
+}
+var route = {
+  next: `import { exportSearchIndexes } from '@/lib/export-search-indexes';
+
+export const revalidate = false;
+
+export async function GET() {
+  return Response.json(await exportSearchIndexes());
+}`,
+  "react-router": `import { exportSearchIndexes } from '@/lib/export-search-indexes';
+
+export async function loader() {
+  return Response.json(await exportSearchIndexes());
+}`,
+  tanstack: `import { createFileRoute } from '@tanstack/react-router';
+import { exportSearchIndexes } from '@/lib/export-search-indexes';
+
+export const Route = createFileRoute('/static.json')({
+  server: {
+    handlers: {
+      GET: async () => Response.json(await exportSearchIndexes()),
+    },
+  },
+});`,
+  waku: `import { exportSearchIndexes } from '@/lib/export-search-indexes';
+
+export async function GET() {
+  return Response.json(await exportSearchIndexes());
+}
+
+export const getConfig = () => ({
+  render: 'static',
+});`
+};
+export {
+  oramaCloud
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-fumadocs-app",
-  "version": "16.0.1",
+  "version": "16.0.3",
   "description": "Create a new documentation site with Fumadocs",
   "keywords": [
     "NextJs",
@@ -24,7 +24,8 @@
     "@clack/prompts": "^0.11.0",
     "commander": "^14.0.1",
     "picocolors": "^1.1.1",
-    "tinyexec": "^1.0.1"
+    "tinyexec": "^1.0.1",
+    "ts-morph": "^27.0.2"
   },
   "devDependencies": {
     "@types/cross-spawn": "^6.0.6",
@@ -45,6 +46,7 @@
     "clean": "rimraf dist",
     "dev": "tsup --watch",
     "lint": "eslint .",
-    "types:check": "tsc --noEmit"
+    "types:check": "tsc --noEmit",
+    "sync": "bun ./scripts/sync.ts"
   }
 }

package/template/+next+fuma-docs-mdx/app/(home)/page.tsx

@@ -0,0 +1,16 @@
+import Link from 'next/link';
+
+export default function HomePage() {
+  return (
+    <div className="flex flex-col justify-center text-center flex-1">
+      <h1 className="text-2xl font-bold mb-4">Hello World</h1>
+      <p>
+        You can open{' '}
+        <Link href="/docs" className="font-medium underline">
+          /docs
+        </Link>{' '}
+        and see the documentation.
+      </p>
+    </div>
+  );
+}

package/template/{+next+tailwindcss → +next+fuma-docs-mdx}/app/layout.tsx

@@ -1,5 +1,5 @@
-import '@/app/global.css';
 import { RootProvider } from 'fumadocs-ui/provider/next';
+import './global.css';
 import { Inter } from 'next/font/google';
 
 const inter = Inter({

package/template/{+next → +next+fuma-docs-mdx}/example.gitignore

@@ -2,8 +2,6 @@
 /node_modules
 
 # generated content
-.contentlayer
-.content-collections
 .source
 
 # test & build

package/template/+next+fuma-docs-mdx/lib/layout.shared.tsx

@@ -0,0 +1,9 @@
+import type { BaseLayoutProps } from 'fumadocs-ui/layouts/shared';
+
+export function baseOptions(): BaseLayoutProps {
+  return {
+    nav: {
+      title: 'My App',
+    },
+  };
+}

package/template/+next+fuma-docs-mdx/lib/source.ts

@@ -21,7 +21,7 @@ export function getPageImage(page: InferPageType<typeof source>) {
 export async function getLLMText(page: InferPageType<typeof source>) {
   const processed = await page.data.getText('processed');
 
-  return `# ${page.data.title} (${page.url})
+  return `# ${page.data.title}
 
 ${processed}`;
 }

package/template/{+next → +next+fuma-docs-mdx}/mdx-components.tsx

@@ -1,7 +1,6 @@
 import defaultMdxComponents from 'fumadocs-ui/mdx';
 import type { MDXComponents } from 'mdx/types';
 
-// use this function to get MDX components, you will need it for rendering MDX
 export function getMDXComponents(components?: MDXComponents): MDXComponents {
   return {
     ...defaultMdxComponents,

package/template/+next+fuma-docs-mdx/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "example-next-mdx",
+  "version": "0.0.0",
+  "private": true,
+  "scripts": {
+    "build": "next build",
+    "dev": "next dev",
+    "start": "next start"
+  },
+  "dependencies": {
+    "fumadocs-core": "workspace:*",
+    "fumadocs-mdx": "workspace:*",
+    "fumadocs-ui": "workspace:*",
+    "lucide-react": "^0.546.0",
+    "next": "16.0.0",
+    "react": "^19.2.0",
+    "react-dom": "^19.2.0"
+  },
+  "devDependencies": {
+    "@tailwindcss/postcss": "^4.1.15",
+    "@types/mdx": "^2.0.13",
+    "@types/node": "^24.9.1",
+    "@types/react": "^19.2.2",
+    "@types/react-dom": "^19.2.2",
+    "postcss": "^8.5.6",
+    "tailwindcss": "^4.1.15",
+    "typescript": "^5.9.3"
+  }
+}

package/template/+next+fuma-docs-mdx/source.config.ts

@@ -8,6 +8,7 @@ import {
 // You can customise Zod schemas for frontmatter and `meta.json` here
 // see https://fumadocs.dev/docs/mdx/collections
 export const docs = defineDocs({
+  dir: 'content/docs',
   docs: {
     schema: frontmatterSchema,
     postprocess: {

package/template/+next+fuma-docs-mdx/tsconfig.json

@@ -16,8 +16,8 @@
     "jsx": "preserve",
     "incremental": true,
     "paths": {
-      "@/.source": [".source"],
-      "@/*": ["./*"]
+      "@/*": ["./*"],
+      "@/.source": [".source"]
     },
     "plugins": [
       {

package/template/+orama-cloud/@app/components/search.tsx

@@ -0,0 +1,59 @@
+'use client';
+
+import {
+  SearchDialog,
+  SearchDialogClose,
+  SearchDialogContent,
+  SearchDialogFooter,
+  SearchDialogHeader,
+  SearchDialogIcon,
+  SearchDialogInput,
+  SearchDialogList,
+  SearchDialogOverlay,
+  type SharedProps,
+} from 'fumadocs-ui/components/dialog/search';
+import { useDocsSearch } from 'fumadocs-core/search/client';
+import { OramaCloud } from '@orama/core';
+import { useI18n } from 'fumadocs-ui/contexts/i18n';
+
+const client = new OramaCloud({
+  projectId: process.env.NEXT_PUBLIC_ORAMA_DATASOURCE_ID,
+  apiKey: process.env.NEXT_PUBLIC_ORAMA_API_KEY,
+});
+
+export default function CustomSearchDialog(props: SharedProps) {
+  const { locale } = useI18n(); // (optional) for i18n
+  const { search, setSearch, query } = useDocsSearch({
+    type: 'orama-cloud',
+    client,
+    locale,
+  });
+
+  return (
+    <SearchDialog
+      search={search}
+      onSearchChange={setSearch}
+      isLoading={query.isLoading}
+      {...props}
+    >
+      <SearchDialogOverlay />
+      <SearchDialogContent>
+        <SearchDialogHeader>
+          <SearchDialogIcon />
+          <SearchDialogInput />
+          <SearchDialogClose />
+        </SearchDialogHeader>
+        <SearchDialogList items={query.data !== 'empty' ? query.data : null} />
+        <SearchDialogFooter>
+          <a
+            href="https://orama.com"
+            rel="noreferrer noopener"
+            className="ms-auto text-xs text-fd-muted-foreground"
+          >
+            Search powered by Orama
+          </a>
+        </SearchDialogFooter>
+      </SearchDialogContent>
+    </SearchDialog>
+  );
+}

package/template/+orama-cloud/@app/lib/export-static-indexes.ts

@@ -0,0 +1,14 @@
+import { source } from '@/lib/source';
+import type { OramaDocument } from 'fumadocs-core/search/orama-cloud';
+
+export async function exportSearchIndexes() {
+  return source.getPages().map((page) => {
+    return {
+      id: page.url,
+      structured: page.data.structuredData,
+      url: page.url,
+      title: page.data.title,
+      description: page.data.description,
+    } satisfies OramaDocument;
+  });
+}

package/template/+orama-cloud/@root/.env.example

@@ -0,0 +1,6 @@
+NEXT_PUBLIC_ORAMA_DATASOURCE_ID="Rest API data source ID"
+NEXT_PUBLIC_ORAMA_PROJECT_ID="project ID"
+NEXT_PUBLIC_ORAMA_API_KEY="public API key"
+
+# keep it secretly!
+ORAMA_PRIVATE_API_KEY="private API key"

package/template/react-router/app/docs/page.tsx

@@ -7,11 +7,11 @@ import {
   DocsTitle,
 } from 'fumadocs-ui/page';
 import { source } from '@/lib/source';
-import { baseOptions } from '@/lib/layout.shared';
 import type * as PageTree from 'fumadocs-core/page-tree';
 import defaultMdxComponents from 'fumadocs-ui/mdx';
 import { docs } from '@/.source';
 import { toClientRenderer } from 'fumadocs-mdx/runtime/vite';
+import { baseOptions } from '@/lib/layout.shared';
 
 export async function loader({ params }: Route.LoaderArgs) {
   const slugs = params['*'].split('/').filter((v) => v.length > 0);
@@ -20,7 +20,7 @@ export async function loader({ params }: Route.LoaderArgs) {
 
   return {
     path: page.path,
-    tree: source.pageTree,
+    tree: source.getPageTree(),
   };
 }
 
@@ -41,8 +41,8 @@ const renderer = toClientRenderer(
   },
 );
 
-export default function Page(props: Route.ComponentProps) {
-  const { tree, path } = props.loaderData;
+export default function Page({ loaderData }: Route.ComponentProps) {
+  const { tree, path } = loaderData;
   const Content = renderer[path];
 
   return (

package/template/react-router/example.gitignore

@@ -4,5 +4,4 @@
 # React Router
 /.react-router/
 /build/
-
 .source

package/template/react-router/react-router.config.ts

@@ -8,10 +8,10 @@ export default {
   ssr: true,
   async prerender({ getStaticPaths }) {
     const paths: string[] = [];
+    const excluded: string[] = ['/api/search'];
+
     for (const path of getStaticPaths()) {
-      // ignore dynamic document search
-      if (path === '/api/search') continue;
-      paths.push(path);
+      if (!excluded.includes(path)) paths.push(path);
     }
 
     for await (const entry of glob('**/*.mdx', { cwd: 'content/docs' })) {

package/template/react-router-spa/README.md

@@ -0,0 +1,12 @@
+This is a React Router application generated with
+[Create Fumadocs](https://github.com/fuma-nama/fumadocs).
+
+Run development server:
+
+```bash
+npm run dev
+# or
+pnpm dev
+# or
+yarn dev
+```

package/template/react-router-spa/app/app.css

@@ -0,0 +1,3 @@
+@import 'tailwindcss';
+@import 'fumadocs-ui/css/neutral.css';
+@import 'fumadocs-ui/css/preset.css';

package/template/react-router-spa/app/components/search.tsx

@@ -0,0 +1,50 @@
+'use client';
+import {
+  SearchDialog,
+  SearchDialogClose,
+  SearchDialogContent,
+  SearchDialogHeader,
+  SearchDialogIcon,
+  SearchDialogInput,
+  SearchDialogList,
+  SearchDialogOverlay,
+  type SharedProps,
+} from 'fumadocs-ui/components/dialog/search';
+import { useDocsSearch } from 'fumadocs-core/search/client';
+import { create } from '@orama/orama';
+import { useI18n } from 'fumadocs-ui/contexts/i18n';
+
+function initOrama() {
+  return create({
+    schema: { _: 'string' },
+    language: 'english',
+  });
+}
+
+export default function DefaultSearchDialog(props: SharedProps) {
+  const { locale } = useI18n();
+  const { search, setSearch, query } = useDocsSearch({
+    type: 'static',
+    initOrama,
+    locale,
+  });
+
+  return (
+    <SearchDialog
+      search={search}
+      onSearchChange={setSearch}
+      isLoading={query.isLoading}
+      {...props}
+    >
+      <SearchDialogOverlay />
+      <SearchDialogContent>
+        <SearchDialogHeader>
+          <SearchDialogIcon />
+          <SearchDialogInput />
+          <SearchDialogClose />
+        </SearchDialogHeader>
+        <SearchDialogList items={query.data !== 'empty' ? query.data : null} />
+      </SearchDialogContent>
+    </SearchDialog>
+  );
+}