create-fumadocs-app 16.0.3 → 16.0.4

package/dist/plugins/orama-cloud.js

@@ -0,0 +1,359 @@
+import {
+  copy,
+  depVersions,
+  pick,
+  sourceDir,
+  writeFile
+} from "../chunk-ZWEHS3HT.js";
+
+// src/plugins/orama-cloud.ts
+import path2 from "path";
+import fs3 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(path3) {
+  return project.createSourceFile(path3, (await fs.readFile(path3)).toString(), {
+    overwrite: true
+  });
+}
+function getCodeValue(v) {
+  return new Function(`return ${v}`)();
+}
+
+// src/transform/index.ts
+import path from "path";
+
+// src/transform/react-router.ts
+import {
+  ts
+} from "ts-morph";
+var SyntaxKind = ts.SyntaxKind;
+function filterReactRouterPrerenderArray(sourceFile, array, filter) {
+  const methodBody = getPrerenderMethod(sourceFile)?.getBody();
+  if (!methodBody) return;
+  const initializer = methodBody.getDescendantsOfKind(SyntaxKind.VariableDeclaration).find((item) => item.getName() === array)?.getInitializerIfKind(SyntaxKind.ArrayLiteralExpression);
+  if (!initializer) return;
+  for (const element of initializer.getElements()) {
+    if (!filter(getCodeValue(element.getText()))) {
+      initializer.removeElement(element);
+    }
+  }
+}
+function addReactRouterRoute(sourceFile, routes) {
+  modifyReactRouterRoutes(sourceFile, (arr) => {
+    for (const { path: path3, entry } of routes) {
+      arr.addElement(`route('${path3}', '${entry}')`);
+    }
+  });
+}
+function filterReactRouterRoute(sourceFile, filter) {
+  modifyReactRouterRoutes(sourceFile, (arr) => {
+    for (const element of arr.getElements()) {
+      if (!element.isKind(SyntaxKind.CallExpression) || element.getFirstChildByKind(SyntaxKind.Identifier)?.getText() !== "route")
+        continue;
+      const args = element.getArguments();
+      if (filter({
+        path: getCodeValue(args[0].getText()),
+        entry: getCodeValue(args[1].getText())
+      }))
+        continue;
+      arr.removeElement(element);
+    }
+  });
+}
+function modifyReactRouterRoutes(sourceFile, mod) {
+  const initializer = sourceFile.getDefaultExportSymbol()?.getValueDeclaration()?.getFirstDescendantByKind(SyntaxKind.ArrayLiteralExpression);
+  if (initializer) mod(initializer);
+}
+function getPrerenderMethod(sourceFile) {
+  return sourceFile.getDefaultExportSymbol()?.getValueDeclaration()?.getFirstDescendantByKind(SyntaxKind.ObjectLiteralExpression)?.getProperty("prerender")?.asKind(SyntaxKind.MethodDeclaration) ?? null;
+}
+
+// src/transform/index.ts
+import fs2 from "fs/promises";
+
+// src/transform/tanstack-start.ts
+import { SyntaxKind as SyntaxKind2 } from "ts-morph";
+function addTanstackPrerender(sourceFile, paths) {
+  const optionsArg = getTanstackStartCall(sourceFile)?.getArguments()[0]?.asKind(SyntaxKind2.ObjectLiteralExpression);
+  if (!optionsArg) {
+    return;
+  }
+  const pagesProperty = optionsArg.getProperty("pages")?.asKind(SyntaxKind2.PropertyAssignment);
+  function toItem(path3) {
+    return `{ path: '${path3}' }`;
+  }
+  if (pagesProperty) {
+    const initializer = pagesProperty.getInitializerIfKindOrThrow(
+      SyntaxKind2.ArrayLiteralExpression
+    );
+    const existingPaths = /* @__PURE__ */ new Set();
+    for (const element of initializer.getElements()) {
+      const value = element.asKind(SyntaxKind2.ObjectLiteralExpression)?.getProperty("path")?.asKind(SyntaxKind2.PropertyAssignment)?.getInitializer()?.getText();
+      if (value) {
+        existingPaths.add(getCodeValue(value));
+      }
+    }
+    for (const path3 of paths) {
+      if (existingPaths.has(path3)) continue;
+      initializer.addElement(toItem(path3));
+    }
+  } else {
+    optionsArg.addProperty(
+      `pages: [
+${paths.map((path3) => `  ${toItem(path3)}`).join(",\n")}
+]`
+    );
+  }
+}
+function getTanstackStartCall(sourceFile) {
+  const pluginsProperty = sourceFile.getDefaultExportSymbol()?.getValueDeclaration()?.getFirstDescendantByKind(SyntaxKind2.ObjectLiteralExpression)?.getProperty("plugins")?.getFirstChildByKind(SyntaxKind2.ArrayLiteralExpression);
+  if (!pluginsProperty) return;
+  for (const element of pluginsProperty.getElements()) {
+    const expression = element.asKind(SyntaxKind2.CallExpression);
+    if (expression?.getFirstChildByKind(SyntaxKind2.Identifier)?.getText() === "tanstackStart") {
+      return expression;
+    }
+  }
+}
+
+// src/transform/index.ts
+import { StructureKind, SyntaxKind as SyntaxKind3 } from "ts-morph";
+async function rootProvider({ appDir, template }, fn) {
+  const file = await createSourceFile(
+    path.join(appDir, template.rootProviderPath)
+  );
+  fn({
+    addSearchDialog(specifier) {
+      const elements = file.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 }}"
+        });
+      }
+      file.addImportDeclaration({
+        moduleSpecifier: specifier,
+        defaultImport: "SearchDialog"
+      });
+    }
+  });
+  await file.save();
+}
+async function reactRouterRoutes({ dest, appDir }, fn) {
+  const configFile = await createSourceFile(
+    path.join(dest, "react-router.config.ts")
+  );
+  const routesFile = await createSourceFile(path.join(appDir, "routes.ts"));
+  const tasks = [];
+  function normalizePath(v) {
+    return v.split("/").filter(Boolean).join("/");
+  }
+  fn({
+    addRoute: (p, entry, code) => {
+      addReactRouterRoute(routesFile, [{ path: p, entry }]);
+      if (code) {
+        tasks.push(fs2.writeFile(path.join(appDir, entry), code));
+      }
+    },
+    removeRoute: (p) => {
+      const normalizedPath = normalizePath(p);
+      filterReactRouterRoute(routesFile, (item) => {
+        if (normalizePath(item.path) !== normalizedPath) return true;
+        tasks.push(fs2.unlink(path.join(appDir, item.entry)).catch(() => null));
+        return false;
+      });
+      filterReactRouterPrerenderArray(
+        configFile,
+        "excluded",
+        (item) => normalizePath(item) !== normalizedPath
+      );
+      filterReactRouterPrerenderArray(
+        configFile,
+        "paths",
+        (item) => normalizePath(item) !== normalizedPath
+      );
+    }
+  });
+  await Promise.all([...tasks, routesFile.save(), configFile.save()]);
+}
+async function tanstackStartRoutes({ appDir, dest }, fn) {
+  const configFile = await createSourceFile(path.join(dest, "vite.config.ts"));
+  const tasks = [];
+  fn({
+    addRoute(options) {
+      if (options.code) {
+        tasks.push(
+          fs2.writeFile(path.join(appDir, "routes", options.path), options.code)
+        );
+      }
+      if (options.prerender) {
+        addTanstackPrerender(configFile, [options.route]);
+      }
+    },
+    removeRoute(options) {
+      tasks.push(
+        fs2.unlink(path.join(appDir, "routes", options.path)).catch(() => null)
+      );
+    }
+  });
+  await Promise.all([...tasks, configFile.save()]);
+}
+
+// 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, appDir, template } = this;
+      await copy(path2.join(sourceDir, "template/+orama-cloud/@root"), dest);
+      await copy(path2.join(sourceDir, "template/+orama-cloud/@app"), appDir);
+      await rootProvider(
+        this,
+        (mod) => mod.addSearchDialog("@/components/search")
+      );
+      if (template.value === "tanstack-start") {
+        await tanstackStartRoutes(this, (mod) => {
+          mod.addRoute({
+            path: "static[.]json.ts",
+            route: "/static.json",
+            code: route.tanstack,
+            prerender: true
+          });
+          mod.removeRoute({
+            path: "api/search.ts",
+            route: "/api/search"
+          });
+        });
+      } else if (template.value.startsWith("react-router")) {
+        await reactRouterRoutes(this, (mod) => {
+          mod.addRoute(
+            "static.json",
+            "routes/static.ts",
+            route["react-router"]
+          );
+          mod.removeRoute("api/search");
+        });
+      } else if (template.value.startsWith("+next")) {
+        await Promise.all([
+          fs3.unlink(path2.join(appDir, "app/api/search/route.ts")).catch(() => null),
+          writeFile(path2.join(appDir, "app/static.json/route.ts"), route.next)
+        ]);
+      } else {
+        await Promise.all([
+          fs3.unlink(path2.join(appDir, "pages/api/search.ts")).catch(() => null),
+          writeFile(path2.join(appDir, "pages/static.json.ts"), route.waku)
+        ]);
+      }
+      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(
+        path2.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();`
+      );
+    }
+  };
+}
+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,27 +1,37 @@
 {
   "name": "create-fumadocs-app",
-  "version": "16.0.3",
+  "version": "16.0.4",
   "description": "Create a new documentation site with Fumadocs",
   "keywords": [
-    "NextJs",
-    "next",
     "react",
-    "Docs"
+    "Docs",
+    "Fumadocs"
   ],
   "homepage": "https://fumadocs.dev",
   "repository": "github:fuma-nama/fumadocs",
   "license": "MIT",
   "author": "Fuma Nama",
   "type": "module",
-  "bin": "./dist/index.js",
-  "module": "./dist/create-app.js",
-  "types": "./dist/create-app.d.ts",
+  "bin": "./dist/bin.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./plugins/*": {
+      "import": "./dist/plugins/*.js",
+      "types": "./dist/plugins/*.d.ts"
+    }
+  },
   "files": [
     "template/*",
     "dist/*"
   ],
   "dependencies": {
     "@clack/prompts": "^0.11.0",
+    "@commander-js/extra-typings": "^14.0.0",
     "commander": "^14.0.1",
     "picocolors": "^1.1.1",
     "tinyexec": "^1.0.1",

package/dist/chunk-3VWJJEHU.js

@@ -1,204 +0,0 @@
-import {
-  copy,
-  cwd,
-  depVersions,
-  pick,
-  sourceDir,
-  templates,
-  tryGitInit
-} from "./chunk-HLHY7KAF.js";
-
-// src/create-app.ts
-import path from "path";
-import fs from "fs/promises";
-
-// src/auto-install.ts
-import { x } from "tinyexec";
-var managers = ["npm", "yarn", "bun", "pnpm"];
-function getPackageManager() {
-  const userAgent = process.env.npm_config_user_agent ?? "";
-  if (userAgent.startsWith("yarn")) {
-    return "yarn";
-  }
-  if (userAgent.startsWith("pnpm")) {
-    return "pnpm";
-  }
-  if (userAgent.startsWith("bun")) {
-    return "bun";
-  }
-  return "npm";
-}
-async function autoInstall(manager, dest) {
-  await x(manager, ["install"], {
-    throwOnError: true,
-    nodeOptions: {
-      env: {
-        ...process.env,
-        NODE_ENV: "development",
-        DISABLE_OPENCOLLECTIVE: "1"
-      },
-      cwd: dest
-    }
-  });
-}
-
-// src/create-app.ts
-function defaults(options) {
-  return {
-    ...options,
-    plugins: options.plugins ?? [],
-    useSrcDir: options.template.startsWith("+next") && options.useSrcDir === true,
-    lint: options.lint ?? false,
-    initializeGit: options.initializeGit ?? false,
-    installDeps: options.installDeps ?? false,
-    log: console.log
-  };
-}
-function isRelative(dir, file) {
-  return !path.relative(dir, file).startsWith(`..${path.sep}`);
-}
-async function create(createOptions) {
-  const options = defaults(createOptions);
-  const {
-    outputDir,
-    useSrcDir,
-    log,
-    installDeps,
-    template,
-    lint,
-    initializeGit,
-    packageManager,
-    plugins
-  } = options;
-  const projectName = path.basename(outputDir);
-  const dest = path.resolve(cwd, outputDir);
-  const isNext = options.template.startsWith("+next");
-  const pluginContext = {
-    template: templates.find((item) => item.value === template),
-    dest,
-    options
-  };
-  await copy(path.join(sourceDir, `template/${template}`), dest, {
-    rename(file) {
-      file = file.replace("example.gitignore", ".gitignore");
-      if (useSrcDir && (path.basename(file) === "mdx-components.tsx" || isRelative(path.join(dest, "app"), file) || isRelative(path.join(dest, "lib"), file))) {
-        return path.join(dest, "src", path.relative(dest, file));
-      }
-      return file;
-    }
-  });
-  if (isNext && lint) {
-    await copy(path.join(sourceDir, `template/+next+${lint}`), dest);
-    log("Configured Linter");
-  }
-  if (isNext && useSrcDir) {
-    const tsconfigPath = path.join(dest, "tsconfig.json");
-    const content = (await fs.readFile(tsconfigPath)).toString();
-    const config = JSON.parse(content);
-    if (config.compilerOptions?.paths) {
-      Object.assign(config.compilerOptions.paths, {
-        "@/*": ["./src/*"]
-      });
-    }
-    await fs.writeFile(tsconfigPath, JSON.stringify(config, null, 2));
-  }
-  let packageJson = await createPackageJson(projectName, dest, options);
-  for (const plugin of plugins) {
-    const result = await plugin.packageJson?.call(pluginContext, packageJson);
-    if (result) packageJson = result;
-  }
-  await fs.writeFile(
-    path.join(dest, "package.json"),
-    JSON.stringify(packageJson, null, 2)
-  );
-  let readme = await getReadme(dest, projectName);
-  for (const plugin of plugins) {
-    readme = await plugin.readme?.call(pluginContext, readme) ?? readme;
-  }
-  await fs.writeFile(path.join(dest, "README.md"), readme);
-  for (const plugin of plugins) {
-    await plugin.afterWrite?.call(pluginContext);
-  }
-  if (installDeps) {
-    try {
-      await autoInstall(packageManager, dest);
-      log("Installed dependencies");
-    } catch (err) {
-      log(`Failed to install dependencies: ${err}`);
-    }
-  }
-  if (initializeGit && await tryGitInit(dest)) {
-    log("Initialized Git repository");
-  }
-}
-async function getReadme(dest, projectName) {
-  const template = await fs.readFile(path.join(dest, "README.md")).then((res) => res.toString());
-  return `# ${projectName}
-
-${template}`;
-}
-async function createPackageJson(projectName, dir, { template, lint }) {
-  const isNext = template.startsWith("+next");
-  function replaceWorkspaceDeps(deps) {
-    for (const k in deps) {
-      if (deps[k].startsWith("workspace:") && k in depVersions) {
-        deps[k] = depVersions[k];
-      }
-    }
-    return deps;
-  }
-  let packageJson = JSON.parse(
-    await fs.readFile(path.join(dir, "package.json")).then((res) => res.toString())
-  );
-  packageJson = {
-    name: projectName,
-    ...packageJson,
-    dependencies: replaceWorkspaceDeps(packageJson.dependencies),
-    devDependencies: replaceWorkspaceDeps(packageJson.devDependencies)
-  };
-  if (isNext) {
-    packageJson = {
-      ...packageJson,
-      scripts: {
-        ...packageJson.scripts,
-        postinstall: "fumadocs-mdx"
-      }
-    };
-  }
-  if (isNext && lint === "biome") {
-    packageJson = {
-      ...packageJson,
-      scripts: {
-        ...packageJson.scripts,
-        lint: "biome check",
-        format: "biome format --write"
-      },
-      devDependencies: {
-        ...packageJson.devDependencies,
-        ...pick(depVersions, ["@biomejs/biome"])
-      }
-    };
-  }
-  if (isNext && lint === "eslint") {
-    packageJson = {
-      ...packageJson,
-      scripts: {
-        ...packageJson.scripts,
-        lint: "eslint"
-      },
-      devDependencies: {
-        ...packageJson.devDependencies,
-        eslint: "^9",
-        "eslint-config-next": depVersions.next,
-        "@eslint/eslintrc": "^3"
-      }
-    };
-  }
-  return packageJson;
-}
-
-export {
-  managers,
-  getPackageManager,
-  create
-};

package/dist/create-app.d.ts

@@ -1,49 +0,0 @@
-type PackageManager = (typeof managers)[number];
-declare const managers: readonly ["npm", "yarn", "bun", "pnpm"];
-
-interface TemplateInfo {
-    value: '+next+fuma-docs-mdx' | 'waku' | 'react-router' | 'react-router-spa' | 'tanstack-start';
-    label: string;
-    hint?: string;
-}
-
-type Template = TemplateInfo['value'];
-interface Options {
-    outputDir: string;
-    template: Template;
-    /**
-     * the package manager to use
-     */
-    packageManager: PackageManager;
-    /**
-     * (Next.js only) Create files inside `src`
-     * @defaultValue false
-     */
-    useSrcDir?: boolean;
-    /**
-     * (Next.js Only) Configure Lint
-     * @defaultValue false
-     */
-    lint?: 'eslint' | 'biome' | false;
-    installDeps?: boolean;
-    initializeGit?: boolean;
-    log?: (message: string) => void;
-    plugins?: TemplatePlugin[];
-}
-interface TemplatePluginContext {
-    template: TemplateInfo;
-    options: Required<Options>;
-    /**
-     * output directory
-     */
-    dest: string;
-}
-type Awaitable<T> = T | Promise<T>;
-interface TemplatePlugin {
-    packageJson?: (this: TemplatePluginContext, packageJson: any) => Awaitable<void | any>;
-    afterWrite?: (this: TemplatePluginContext) => Awaitable<void>;
-    readme?: (this: TemplatePluginContext, content: string) => Awaitable<void | string>;
-}
-declare function create(createOptions: Options): Promise<void>;
-
-export { type Options, type Template, type TemplatePlugin, type TemplatePluginContext, create };

package/dist/create-app.js

@@ -1,7 +0,0 @@
-import {
-  create
-} from "./chunk-3VWJJEHU.js";
-import "./chunk-HLHY7KAF.js";
-export {
-  create
-};