fuma-content 0.0.2 → 1.0.0

package/dist/next/index.d.ts

@@ -0,0 +1,27 @@
+import { NextConfig } from 'next';
+import { a as Core } from '../core-DxnSmTRe.js';
+import 'chokidar';
+import '@mdx-js/mdx';
+import 'vfile';
+import '@standard-schema/spec';
+import 'unified';
+import 'mdast';
+import 'vite';
+import 'node:module';
+
+interface NextOptions {
+    /**
+     * Path to source configuration file
+     */
+    configPath?: string;
+    /**
+     * Directory for output files
+     *
+     * @defaultValue '.content'
+     */
+    outDir?: string;
+}
+declare function createContent(nextOptions?: NextOptions): Promise<(nextConfig?: NextConfig) => NextConfig>;
+declare function createStandaloneCore(options: NextOptions): Promise<Core>;
+
+export { type NextOptions, createContent, createStandaloneCore };

package/dist/next/index.js

@@ -0,0 +1,99 @@
+import {
+  loadConfig
+} from "../chunk-M72VQL5M.js";
+import "../chunk-IGLM4N4P.js";
+import {
+  Core
+} from "../chunk-Z7KHD7MS.js";
+import "../chunk-6XDQG2GV.js";
+
+// src/next/index.ts
+import * as path from "path";
+async function createContent(nextOptions = {}) {
+  const core = createNextCore(applyDefaults(nextOptions));
+  await core.init({
+    config: loadConfig(core, true)
+  });
+  if (process.env._FUMADOCS_MDX !== "1") {
+    process.env._FUMADOCS_MDX = "1";
+    await core.emit({ write: true });
+    await init(process.env.NODE_ENV === "development", core);
+  }
+  return (nextConfig = {}) => {
+    const ctx = core.getPluginContext();
+    for (const plugin of core.getPlugins(true)) {
+      nextConfig = plugin.next?.config?.call(ctx, nextConfig) ?? nextConfig;
+    }
+    return nextConfig;
+  };
+}
+async function init(dev, core) {
+  if (!dev) return;
+  const { FSWatcher } = await import("chokidar");
+  const { configPath, outDir } = core.getOptions();
+  const absoluteConfigPath = path.resolve(configPath);
+  let watcher;
+  async function devServer() {
+    if (watcher && !watcher.closed) {
+      await watcher.close();
+    }
+    watcher = new FSWatcher({
+      ignoreInitial: true,
+      persistent: true,
+      ignored: [outDir]
+    });
+    watcher.add(configPath);
+    for (const collection of core.getCollections(true)) {
+      const handler = collection.handlers.fs;
+      if (handler) {
+        watcher.add(handler.dir);
+      }
+    }
+    watcher.once("ready", () => {
+      console.log("[MDX] started dev server");
+    });
+    watcher.on("all", (_event, file) => {
+      if (path.resolve(file) === absoluteConfigPath) {
+        console.log("[MDX] restarting dev server");
+        watcher?.removeAllListeners();
+        void (async () => {
+          await core.init({
+            config: loadConfig(core, true)
+          });
+          await devServer();
+          await core.emit({ write: true });
+        })();
+      }
+    });
+    await core.initServer({ watcher });
+  }
+  process.on("exit", () => {
+    if (!watcher || watcher.closed) return;
+    console.log("[MDX] closing dev server");
+    void watcher.close();
+  });
+  await devServer();
+}
+async function createStandaloneCore(options) {
+  const core = createNextCore(applyDefaults(options));
+  await core.init({
+    config: loadConfig(core, true)
+  });
+  return core;
+}
+function applyDefaults(options) {
+  return {
+    outDir: options.outDir ?? Core.defaultOptions.outDir,
+    configPath: options.configPath ?? Core.defaultOptions.configPath
+  };
+}
+function createNextCore(options) {
+  return new Core({
+    outDir: options.outDir,
+    configPath: options.configPath
+  });
+}
+export {
+  createContent,
+  createStandaloneCore
+};

package/dist/node/loader.d.ts

@@ -0,0 +1,5 @@
+import { LoadHook } from 'node:module';
+
+declare const load: LoadHook;
+
+export { load };

package/dist/node/loader.js

@@ -0,0 +1,46 @@
+import {
+  createDynamicCore
+} from "../chunk-LDBQ66H3.js";
+import {
+  Core
+} from "../chunk-Z7KHD7MS.js";
+import {
+  createCache
+} from "../chunk-6XDQG2GV.js";
+
+// src/node/loader.ts
+var configLoader = createDynamicCore({
+  core: new Core({
+    configPath: Core.defaultOptions.configPath,
+    outDir: Core.defaultOptions.outDir
+  }),
+  buildConfig: true,
+  mode: "production"
+});
+var load = async (url, context, nextLoad) => {
+  const core = await configLoader.getCore();
+  const store = createCache(core.cache);
+  const hooks = await store.cached("node:load-hooks", async () => {
+    const ctx = core.getPluginContext();
+    const hooks2 = await Promise.all(
+      core.getPlugins(true).map(async (plugin) => {
+        return plugin.node?.createLoad?.call(ctx);
+      })
+    );
+    return hooks2.filter((v) => v !== void 0);
+  });
+  function run(i, url2, context2) {
+    if (i >= hooks.length) {
+      return nextLoad(url2, context2);
+    }
+    return hooks[i](
+      url2,
+      context2,
+      (url3, ctx) => run(i + 1, url3, { ...context2, ...ctx })
+    );
+  }
+  return run(0, url, context);
+};
+export {
+  load
+};

package/dist/node-DCMYL4DL.js

@@ -0,0 +1,34 @@
+// src/plugins/with-loader/node.ts
+import { fileURLToPath } from "url";
+import fs from "fs/promises";
+function toNode(test, loader) {
+  return async (url, _context, nextLoad) => {
+    if (url.startsWith("file:///") && (!test || test.test(url))) {
+      const parsedUrl = new URL(url);
+      const filePath = fileURLToPath(parsedUrl);
+      const result = await loader.load({
+        filePath,
+        query: Object.fromEntries(parsedUrl.searchParams.entries()),
+        async getSource() {
+          return (await fs.readFile(filePath)).toString();
+        },
+        development: false,
+        compiler: {
+          addDependency() {
+          }
+        }
+      });
+      if (result) {
+        return {
+          source: result.code,
+          format: "module",
+          shortCircuit: true
+        };
+      }
+    }
+    return nextLoad(url);
+  };
+}
+export {
+  toNode
+};

package/dist/plugins/git.d.ts

@@ -0,0 +1,10 @@
+export { w as GitPluginOptions, x as VersionControlClient, V as VersionControlFileData, v as VersionControlHandler, u as default } from '../core-DxnSmTRe.js';
+import 'chokidar';
+import '@mdx-js/mdx';
+import 'vfile';
+import '@standard-schema/spec';
+import 'unified';
+import 'mdast';
+import 'vite';
+import 'next';
+import 'node:module';

package/dist/plugins/git.js

@@ -0,0 +1,70 @@
+import {
+  createCache
+} from "../chunk-6XDQG2GV.js";
+
+// src/plugins/git.ts
+import path from "path";
+import { x } from "tinyexec";
+function git(options = {}) {
+  const { filter = () => true } = options;
+  let client;
+  return {
+    name: "git",
+    config() {
+      const { workspace } = this.core.getOptions();
+      const cwd = workspace ? path.resolve(workspace.dir) : process.cwd();
+      client = createGitClient(cwd);
+    },
+    collection(collection) {
+      if (!filter(collection.name)) return;
+      const handler = collection.handlers["version-control"];
+      if (!handler) return;
+      return handler.client({ client });
+    }
+  };
+}
+function createGitClient(cwd) {
+  const cache = createCache();
+  function mapDate(out) {
+    if (out.exitCode !== 0) return null;
+    const date = new Date(out.stdout);
+    return Number.isNaN(date.getTime()) ? null : date;
+  }
+  return {
+    async getFileData({ filePath }) {
+      return cache.cached(filePath, async () => {
+        const relativePath = path.relative(cwd, filePath);
+        const [mod, create] = await Promise.all([
+          x("git", ["log", "-1", "--pretty=%ai", relativePath], {
+            nodeOptions: {
+              cwd
+            }
+          }),
+          x(
+            "git",
+            [
+              "log",
+              "--diff-filter=A",
+              "--follow",
+              "--format=%ai",
+              "-1",
+              relativePath
+            ],
+            {
+              nodeOptions: {
+                cwd
+              }
+            }
+          )
+        ]);
+        return {
+          lastModified: mapDate(mod),
+          creationDate: mapDate(create)
+        };
+      });
+    }
+  };
+}
+export {
+  git as default
+};

package/dist/plugins/json-schema.d.ts

@@ -0,0 +1,10 @@
+export { l as JSONSchemaHandler, J as JSONSchemaOptions, k as default } from '../core-DxnSmTRe.js';
+import 'chokidar';
+import '@mdx-js/mdx';
+import 'vfile';
+import '@standard-schema/spec';
+import 'unified';
+import 'mdast';
+import 'vite';
+import 'next';
+import 'node:module';

package/dist/plugins/json-schema.js

@@ -0,0 +1,59 @@
+// src/plugins/json-schema.ts
+import fs from "fs/promises";
+import path from "path";
+function jsonSchema({
+  insert = false
+} = {}) {
+  function getSchemaPath(name) {
+    return `json-schema/${name}.json`;
+  }
+  return {
+    name: "json-schema",
+    configureServer(server) {
+      const { outDir } = this.core.getOptions();
+      if (!server.watcher || !insert) return;
+      server.watcher.on("add", async (file) => {
+        const match = this.core.getCollections().find((collection) => {
+          const handler = collection.handlers.fs;
+          if (!handler) return false;
+          return handler.hasFile(file);
+        });
+        if (!match) return;
+        let obj;
+        try {
+          const content = (await fs.readFile(file)).toString();
+          obj = content.length > 0 ? JSON.parse(content) : {};
+        } catch {
+          return;
+        }
+        if ("$schema" in obj) return;
+        const schemaPath = path.join(
+          outDir,
+          getSchemaPath(parent ? `${parent.name}.meta` : match.name)
+        );
+        const updated = {
+          $schema: path.relative(path.dirname(file), schemaPath),
+          ...obj
+        };
+        await fs.writeFile(file, JSON.stringify(updated, null, 2));
+      });
+    },
+    async emit() {
+      const files = [];
+      for (const collection of this.core.getCollections()) {
+        const handler = collection.handlers["json-schema"];
+        if (!handler) continue;
+        const jsonSchema2 = await handler.create();
+        if (!jsonSchema2) continue;
+        files.push({
+          path: getSchemaPath(collection.name),
+          content: JSON.stringify(jsonSchema2, null, 2)
+        });
+      }
+      return files;
+    }
+  };
+}
+export {
+  jsonSchema as default
+};

package/dist/plugins/with-loader/index.d.ts

@@ -0,0 +1,61 @@
+import { P as PluginContext, d as Plugin } from '../../core-DxnSmTRe.js';
+import 'chokidar';
+import '@mdx-js/mdx';
+import 'vfile';
+import '@standard-schema/spec';
+import 'unified';
+import 'mdast';
+import 'vite';
+import 'next';
+import 'node:module';
+
+type Awaitable<T> = T | Promise<T>;
+interface CompilerOptions {
+    addDependency: (file: string) => void;
+}
+type LoaderEnvironment = "vite" | "bun" | "node";
+interface Loader {
+    /**
+     * Transform input into JavaScript.
+     *
+     * Returns:
+     * - `LoaderOutput`: JavaScript code & source map.
+     * - `null`: skip the loader. Fallback to default behaviour if possible, otherwise the adapter will try workarounds.
+     */
+    load: (input: LoaderInput) => Awaitable<LoaderOutput | null>;
+    bun?: {
+        /**
+         * 1. Bun doesn't allow `null` in loaders.
+         * 2. Bun requires sync result to support dynamic require().
+         */
+        load?: (source: string, input: LoaderInput) => Awaitable<Bun.OnLoadResult>;
+    };
+}
+interface LoaderInput {
+    development: boolean;
+    compiler: CompilerOptions;
+    filePath: string;
+    query: Record<string, string | string[] | undefined>;
+    getSource: () => string | Promise<string>;
+}
+interface LoaderOutput {
+    code: string;
+    map?: unknown;
+}
+interface WithLoaderConfig {
+    /**
+     * Filter file paths, the input can be either a file URL or file path.
+     *
+     * Must take resource query into consideration.
+     */
+    test?: RegExp;
+    createLoader: (this: PluginContext, environment: LoaderEnvironment) => Promise<Loader>;
+}
+/**
+ * a light layer for implementing loaders.
+ *
+ * @remarks it doesn't include Next.js, you have to define the webpack/turbopack config, and export the loaders on your own.
+ */
+declare function withLoader(plugin: Plugin, { test, createLoader }: WithLoaderConfig): Plugin;
+
+export { type CompilerOptions, type Loader, type LoaderInput, type LoaderOutput, type WithLoaderConfig, withLoader };

package/dist/plugins/with-loader/index.js

@@ -0,0 +1,6 @@
+import {
+  withLoader
+} from "../../chunk-ERBMAQYP.js";
+export {
+  withLoader
+};

package/dist/plugins/with-loader/webpack.d.ts

@@ -0,0 +1,27 @@
+import { LoaderContext } from 'webpack';
+import { Loader } from './index.js';
+import { a as Core } from '../../core-DxnSmTRe.js';
+import 'chokidar';
+import '@mdx-js/mdx';
+import 'vfile';
+import '@standard-schema/spec';
+import 'unified';
+import 'mdast';
+import 'vite';
+import 'next';
+import 'node:module';
+
+type WebpackLoader = (this: LoaderContext<unknown>, source: string, callback: LoaderContext<unknown>["callback"]) => Promise<void>;
+interface WebpackLoaderOptions {
+    absoluteCompiledConfigPath: string;
+    configPath: string;
+    outDir: string;
+    isDev: boolean;
+}
+declare function getCore(options: WebpackLoaderOptions): Core;
+/**
+ * need to handle the `test` regex in Webpack config instead.
+ */
+declare function toWebpack(loader: Loader): WebpackLoader;
+
+export { type WebpackLoader, type WebpackLoaderOptions, getCore, toWebpack };

package/dist/plugins/with-loader/webpack.js

@@ -0,0 +1,11 @@
+import {
+  getCore,
+  toWebpack
+} from "../../chunk-4RMSJCK2.js";
+import "../../chunk-OUJENWQ4.js";
+import "../../chunk-Z7KHD7MS.js";
+import "../../chunk-6XDQG2GV.js";
+export {
+  getCore,
+  toWebpack
+};

package/dist/vite/index.d.ts

@@ -0,0 +1,33 @@
+import { PluginOption } from 'vite';
+import { a as Core } from '../core-DxnSmTRe.js';
+import 'chokidar';
+import '@mdx-js/mdx';
+import 'vfile';
+import '@standard-schema/spec';
+import 'unified';
+import 'mdast';
+import 'next';
+import 'node:module';
+
+interface PluginOptions {
+    /**
+     * @defaultValue content.config.ts
+     */
+    configPath?: string;
+    /**
+     * Update Vite config to fix module resolution of Fumadocs
+     *
+     * @defaultValue true
+     */
+    updateViteConfig?: boolean;
+    /**
+     * Output directory of generated files
+     *
+     * @defaultValue '.content'
+     */
+    outDir?: string;
+}
+declare function content(config: Record<string, unknown>, pluginOptions?: PluginOptions): Promise<PluginOption[]>;
+declare function createStandaloneCore(pluginOptions?: PluginOptions): Promise<Core>;
+
+export { type PluginOptions, createStandaloneCore, content as default };

package/dist/vite/index.js

@@ -0,0 +1,60 @@
+import {
+  buildConfig
+} from "../chunk-IGLM4N4P.js";
+import {
+  Core
+} from "../chunk-Z7KHD7MS.js";
+import "../chunk-6XDQG2GV.js";
+
+// src/vite/index.ts
+async function content(config, pluginOptions = {}) {
+  const options = applyDefaults(pluginOptions);
+  const core = createViteCore(options);
+  await core.init({
+    config: buildConfig(config)
+  });
+  const ctx = core.getPluginContext();
+  return [
+    ...core.getPlugins(true).map((plugin) => plugin.vite?.createPlugin?.call(ctx)),
+    {
+      name: "fuma-content",
+      async buildStart() {
+        await core.emit({ write: true });
+      },
+      async configureServer(server) {
+        await core.initServer({
+          watcher: server.watcher
+        });
+      }
+    }
+  ];
+}
+async function createStandaloneCore(pluginOptions = {}) {
+  const { loadConfig } = await import("../load-from-file-MLL4WQ5J.js");
+  const core = createViteCore(applyDefaults(pluginOptions));
+  await core.init({
+    config: loadConfig(core, true)
+  });
+  return core;
+}
+function createViteCore({ configPath, outDir }) {
+  return new Core({
+    configPath,
+    outDir,
+    emit: {
+      target: "vite",
+      jsExtension: false
+    }
+  });
+}
+function applyDefaults(options) {
+  return {
+    updateViteConfig: options.updateViteConfig ?? true,
+    configPath: options.configPath ?? Core.defaultOptions.configPath,
+    outDir: options.outDir ?? Core.defaultOptions.outDir
+  };
+}
+export {
+  createStandaloneCore,
+  content as default
+};

package/dist/vite-QCUPZHHB.js

@@ -0,0 +1,32 @@
+// src/plugins/with-loader/vite.ts
+import { parse } from "querystring";
+function toVite(name, test, loader) {
+  return {
+    name: `fuma-content:${name}`,
+    async transform(value, id) {
+      if (test && !test.test(id)) return;
+      const [file, query = ""] = id.split("?", 2);
+      const result = await loader.load({
+        filePath: file,
+        query: parse(query),
+        getSource() {
+          return value;
+        },
+        development: this.environment.mode === "dev",
+        compiler: {
+          addDependency: (file2) => {
+            this.addWatchFile(file2);
+          }
+        }
+      });
+      if (result === null) return null;
+      return {
+        code: result.code,
+        map: result.map
+      };
+    }
+  };
+}
+export {
+  toVite
+};