fuma-content 0.0.2 → 1.0.0

package/dist/index.d.ts

@@ -1,33 +1,15 @@
-import { AnyZodObject, z } from 'zod';
-import { MDXContent } from 'mdx/types';
+import { G as GlobalConfig } from './core-DxnSmTRe.js';
+export { a as Core, C as CoreOptions, g as EmitCodeGeneratorContext, f as EmitContext, e as EmitEntry, i as EmitOptions, j as EmitOutput, E as ExtractedReference, d as Plugin, P as PluginContext, h as PluginOption, S as ServerContext } 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';
 
-interface CreateOptions {
-    schema?: AnyZodObject;
-    /**
-     * Filter file paths
-     */
-    include?: string | string[];
-}
-interface Document<Info = unknown> {
-    info: Info;
-    /**
-     * Render data, should be accepted by renderer
-     */
-    renderer: MDXContent;
-    /**
-     * File Path
-     */
-    file: string;
-}
-interface Json<Info = unknown> {
-    info: Info;
-    /**
-     * File Path
-     */
-    file: string;
-}
-type GetInfoType<T extends CreateOptions> = T["schema"] extends AnyZodObject ? z.infer<T["schema"]> : Record<string, unknown>;
-declare function document<T extends CreateOptions>(entryPoint: unknown, options?: T): Document<GetInfoType<T>>[];
-declare function json<T extends CreateOptions>(entryPoint: unknown, options?: T): Json<GetInfoType<T>>[];
+type GetCollectionConfig<Config, Name extends string> = Config extends GlobalConfig<infer Collections> ? Collections[Name] : never;
 
-export { type CreateOptions, type Document, type Json, document, json };
+export type { GetCollectionConfig };

package/dist/index.js

@@ -1,51 +0,0 @@
-// src/source/index.ts
-import { z } from "zod";
-import micromatch from "micromatch";
-var defaultSchema = z.record(z.string(), z.unknown());
-function document(entryPoint, options) {
-  const { schema = defaultSchema, include } = options ?? {};
-  return read(entryPoint, ["md", "mdx"], include).map((item) => {
-    const {
-      default: render,
-      format: _format,
-      file,
-      frontmatter,
-      ...rest
-    } = item;
-    const result = schema.safeParse(frontmatter);
-    if (!result.success) throw createError(file, result.error);
-    return {
-      file,
-      info: result.data,
-      renderer: render,
-      ...rest
-    };
-  });
-}
-function json(entryPoint, options) {
-  const { schema = defaultSchema, include } = options ?? {};
-  return read(entryPoint, ["json"], include).map(
-    ({ file, default: data }) => {
-      const result = schema.safeParse(data);
-      if (!result.success) throw createError(file, result.error);
-      return {
-        file,
-        info: result.data
-      };
-    }
-  );
-}
-function createError(file, err) {
-  const message = `${file}:
-${Object.entries(err.flatten().fieldErrors).map(([k, v]) => `${k}: ${v?.join(", ") ?? ""}`).join("\n")}`;
-  return new Error(message);
-}
-function read(entryPoint, format, include) {
-  const cast = entryPoint;
-  const entries = format.flatMap((f) => cast[f] ?? []);
-  return entries.filter((e) => !include || micromatch.isMatch(e.file, include));
-}
-export {
-  document,
-  json
-};

package/dist/load-from-file-MLL4WQ5J.js

@@ -0,0 +1,7 @@
+import {
+  loadConfig
+} from "./chunk-M72VQL5M.js";
+import "./chunk-IGLM4N4P.js";
+export {
+  loadConfig
+};

package/dist/loader-T756NSCS.js

@@ -0,0 +1,7 @@
+import {
+  createMetaLoader
+} from "./chunk-RMSV4HP6.js";
+import "./chunk-OUJENWQ4.js";
+export {
+  createMetaLoader
+};

package/dist/loader-VGDLYG4T.js

@@ -0,0 +1,7 @@
+import {
+  createMdxLoader
+} from "./chunk-PNA5UGSL.js";
+import "./chunk-VWJKRQZR.js";
+export {
+  createMdxLoader
+};

package/dist/next/index.cjs

@@ -0,0 +1,571 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/next/index.ts
+var next_exports = {};
+__export(next_exports, {
+  createContent: () => createContent,
+  createStandaloneCore: () => createStandaloneCore
+});
+module.exports = __toCommonJS(next_exports);
+var path3 = __toESM(require("path"), 1);
+
+// src/config/load-from-file.ts
+var import_node_url = require("url");
+
+// src/config/build.ts
+function buildConfig(config, workspace) {
+  const collections = /* @__PURE__ */ new Map();
+  const loaded = {};
+  const globalConfig = config.default ?? config;
+  if (globalConfig.collections) {
+    for (const [name, collection] of Object.entries(globalConfig.collections)) {
+      collection.init?.({ name, workspace });
+      collections.set(name, collection);
+    }
+  }
+  return {
+    ...globalConfig,
+    collections,
+    workspaces: Object.fromEntries(
+      Object.entries(loaded.workspaces ?? {}).map(([key, value]) => {
+        return [
+          key,
+          {
+            dir: value.dir,
+            config: buildConfig(value.config, {
+              ...value,
+              name: key
+            })
+          }
+        ];
+      })
+    )
+  };
+}
+
+// src/config/load-from-file.ts
+async function compileConfig(core) {
+  const { build } = await import("esbuild");
+  const { configPath, outDir } = core.getOptions();
+  const transformed = await build({
+    entryPoints: [{ in: configPath, out: "content.config" }],
+    bundle: true,
+    outdir: outDir,
+    target: "node20",
+    write: true,
+    platform: "node",
+    format: "esm",
+    packages: "external",
+    outExtension: {
+      ".js": ".mjs"
+    },
+    allowOverwrite: true
+  });
+  if (transformed.errors.length > 0) {
+    throw new Error("failed to compile configuration file");
+  }
+}
+async function loadConfig(core, build = false) {
+  if (build) await compileConfig(core);
+  const url = (0, import_node_url.pathToFileURL)(core.getCompiledConfigPath());
+  url.searchParams.set("hash", Date.now().toString());
+  const config = import(url.href).then(
+    (loaded) => buildConfig(loaded)
+  );
+  return await config;
+}
+
+// src/core.ts
+var import_node_path2 = __toESM(require("path"), 1);
+var import_promises = __toESM(require("fs/promises"), 1);
+
+// src/utils/code-generator.ts
+var import_node_path = __toESM(require("path"), 1);
+var import_tinyglobby = require("tinyglobby");
+
+// src/utils/async-cache.ts
+function createCache(store = /* @__PURE__ */ new Map()) {
+  return {
+    store,
+    cached(key, fn) {
+      let cached = store.get(key);
+      if (cached) return cached;
+      cached = fn();
+      store.set(key, cached);
+      return cached;
+    }
+  };
+}
+
+// src/utils/code-generator.ts
+function importInfo() {
+  return {
+    named: /* @__PURE__ */ new Map(),
+    namespaces: /* @__PURE__ */ new Set(),
+    isUsed: /* @__PURE__ */ new Set()
+  };
+}
+var CodeGenerator = class {
+  lines = [];
+  globCache;
+  // specifier -> imported members/info
+  importInfos = /* @__PURE__ */ new Map();
+  eagerImportId = 0;
+  options;
+  constructor({
+    target = "default",
+    jsExtension = false,
+    globCache = /* @__PURE__ */ new Map(),
+    outDir = ""
+  }) {
+    this.options = {
+      target,
+      jsExtension,
+      globCache,
+      outDir
+    };
+    this.globCache = createCache(globCache);
+  }
+  addNamespaceImport(namespace, specifier, types = false) {
+    const info = this.importInfos.get(specifier) ?? importInfo();
+    this.importInfos.set(specifier, info);
+    if (!types) info.isUsed.add(namespace);
+    info.namespaces.add(namespace);
+  }
+  addNamedImport(names, specifier, types = false) {
+    const info = this.importInfos.get(specifier) ?? importInfo();
+    this.importInfos.set(specifier, info);
+    for (const name of names) {
+      const [memberName, importName = memberName] = name.split(/\s+as\s+/, 2);
+      info.named.set(importName, memberName);
+      if (!types) info.isUsed.add(importName);
+    }
+  }
+  push(...insert) {
+    this.lines.push(...insert);
+  }
+  async pushAsync(insert) {
+    for (const line of await Promise.all(insert)) {
+      if (line === void 0) continue;
+      this.lines.push(line);
+    }
+  }
+  async generateGlobImport(patterns, options) {
+    if (this.options.target === "vite") {
+      return this.generateViteGlobImport(patterns, options);
+    }
+    return this.generateNodeGlobImport(patterns, options);
+  }
+  generateViteGlobImport(patterns, { base, ...rest }) {
+    patterns = (typeof patterns === "string" ? [patterns] : patterns).map(
+      normalizeViteGlobPath
+    );
+    return `import.meta.glob(${JSON.stringify(patterns)}, ${JSON.stringify(
+      {
+        base: normalizeViteGlobPath(import_node_path.default.relative(this.options.outDir, base)),
+        ...rest
+      },
+      null,
+      2
+    )})`;
+  }
+  async generateNodeGlobImport(patterns, { base, eager = false, query = {}, import: importName }) {
+    const files = await this.globCache.cached(
+      JSON.stringify({ patterns, base }),
+      () => (0, import_tinyglobby.glob)(patterns, {
+        cwd: base
+      })
+    );
+    let code = "{";
+    for (const item of files) {
+      const fullPath = import_node_path.default.join(base, item);
+      const searchParams = new URLSearchParams();
+      for (const [k, v] of Object.entries(query)) {
+        if (v !== void 0) searchParams.set(k, v);
+      }
+      const importPath = `${this.formatImportPath(fullPath)}?${searchParams.toString()}`;
+      if (eager) {
+        const name = `__fd_glob_${this.eagerImportId++}`;
+        this.lines.unshift(
+          importName ? `import { ${importName} as ${name} } from ${JSON.stringify(importPath)}` : `import * as ${name} from ${JSON.stringify(importPath)}`
+        );
+        code += `${JSON.stringify(item)}: ${name}, `;
+      } else {
+        let line = `${JSON.stringify(item)}: () => import(${JSON.stringify(importPath)})`;
+        if (importName) {
+          line += `.then(mod => mod.${importName})`;
+        }
+        code += `${line}, `;
+      }
+    }
+    code += "}";
+    return code;
+  }
+  formatImportPath(file) {
+    const ext = import_node_path.default.extname(file);
+    let filename;
+    if (ext === ".ts") {
+      filename = file.substring(0, file.length - ext.length);
+      if (this.options.jsExtension) filename += ".js";
+    } else {
+      filename = file;
+    }
+    const importPath = slash(import_node_path.default.relative(this.options.outDir, filename));
+    return importPath.startsWith(".") ? importPath : `./${importPath}`;
+  }
+  toString() {
+    const final = ["// @ts-nocheck"];
+    if (this.options.target === "vite") {
+      final.push('/// <reference types="vite/client" />');
+    }
+    for (const [specifier, info] of this.importInfos) {
+      const { namespaces, named, isUsed } = info;
+      for (const namespace of namespaces) {
+        final.push(
+          isUsed.has(namespace) ? `import * as ${namespace} from "${specifier}";` : `import type * as ${namespace} from "${specifier}";`
+        );
+      }
+      const namedImports = [];
+      for (const [importName, memberName] of named) {
+        const item = importName === memberName ? importName : `${memberName} as ${importName}`;
+        namedImports.push(isUsed.has(importName) ? item : `type ${item}`);
+      }
+      if (namedImports.length > 0) {
+        final.push(
+          `import { ${namedImports.join(", ")} } from "${specifier}";`
+        );
+      }
+    }
+    final.push(...this.lines);
+    return final.join("\n");
+  }
+};
+function normalizeViteGlobPath(file) {
+  file = slash(file);
+  if (file.startsWith("./")) return file;
+  if (file.startsWith("/")) return `.${file}`;
+  return `./${file}`;
+}
+function slash(path4) {
+  const isExtendedLengthPath = path4.startsWith("\\\\?\\");
+  if (isExtendedLengthPath) {
+    return path4;
+  }
+  return path4.replaceAll("\\", "/");
+}
+
+// src/core.ts
+async function getPlugins(pluginOptions) {
+  const plugins = [];
+  for (const option of await Promise.all(pluginOptions)) {
+    if (!option) continue;
+    if (Array.isArray(option)) plugins.push(...await getPlugins(option));
+    else plugins.push(option);
+  }
+  return plugins;
+}
+var Core = class _Core {
+  workspaces = /* @__PURE__ */ new Map();
+  options;
+  plugins = [];
+  config;
+  static defaultOptions = {
+    configPath: "content.config.ts",
+    outDir: ".content"
+  };
+  /**
+   * Convenient cache store, reset when config changes.
+   *
+   * You can group namespaces in cache key with ":", like `my-plugin:data`
+   */
+  cache = /* @__PURE__ */ new Map();
+  constructor(options) {
+    this.options = options;
+  }
+  async init({ config: newConfig }) {
+    this.config = await newConfig;
+    this.cache.clear();
+    this.workspaces.clear();
+    const loadedCollectionTypeIds = /* @__PURE__ */ new Set();
+    this.plugins = await getPlugins([
+      this.options.plugins,
+      this.config.plugins,
+      ...this.config.collections.values().map(({ typeInfo }) => {
+        if (loadedCollectionTypeIds.has(typeInfo.id)) return false;
+        loadedCollectionTypeIds.add(typeInfo.id);
+        return typeInfo.plugins;
+      })
+    ]);
+    const ctx = this.getPluginContext();
+    for (const plugin of this.plugins) {
+      const out = await plugin.config?.call(ctx, this.config);
+      if (out) this.config = out;
+    }
+    const { workspace, outDir } = this.options;
+    if (!workspace) {
+      await Promise.all(
+        Object.entries(this.config.workspaces).map(
+          async ([name, workspace2]) => {
+            const child = new _Core({
+              ...this.options,
+              outDir: import_node_path2.default.join(outDir, name),
+              workspace: {
+                name,
+                parent: this,
+                dir: workspace2.dir
+              }
+            });
+            await child.init({ config: workspace2.config });
+            this.workspaces.set(name, child);
+          }
+        )
+      );
+    }
+    await Promise.all(
+      this.config.collections.values().map(async (collection) => {
+        for (const plugin of this.plugins) {
+          await plugin.collection?.call(ctx, collection);
+        }
+      })
+    );
+  }
+  getWorkspaces() {
+    return this.workspaces;
+  }
+  getOptions() {
+    return this.options;
+  }
+  getConfig() {
+    return this.config;
+  }
+  /**
+   * The file path of compiled config file, the file may not exist (e.g. on Vite, or still compiling)
+   */
+  getCompiledConfigPath() {
+    return import_node_path2.default.join(this.options.outDir, "content.config.mjs");
+  }
+  getPlugins(workspace = false) {
+    if (workspace) {
+      const plugins = [...this.plugins];
+      for (const workspace2 of this.workspaces.values()) {
+        plugins.push(...workspace2.plugins);
+      }
+      return plugins;
+    }
+    return this.plugins;
+  }
+  getCollections(workspace = false) {
+    const list = Array.from(this.config.collections.values());
+    if (workspace) {
+      for (const workspace2 of this.workspaces.values()) {
+        list.push(...workspace2.getCollections());
+      }
+    }
+    return list;
+  }
+  getCollection(name) {
+    return this.config.collections.get(name);
+  }
+  getPluginContext() {
+    return {
+      core: this
+    };
+  }
+  async initServer(server) {
+    const ctx = this.getPluginContext();
+    const promises = [];
+    for (const plugin of this.plugins) {
+      promises.push(plugin.configureServer?.call(ctx, server));
+    }
+    for (const workspace of this.workspaces.values()) {
+      promises.push(workspace.initServer(server));
+    }
+    await Promise.all(promises);
+  }
+  async emit(emitOptions = {}) {
+    const {
+      workspace,
+      outDir,
+      emit: { target, jsExtension } = {}
+    } = this.options;
+    const { filterPlugin, filterWorkspace, write = false } = emitOptions;
+    const start = performance.now();
+    const globCache = /* @__PURE__ */ new Map();
+    const ctx = {
+      ...this.getPluginContext(),
+      createCodeGenerator: async (path4, content) => {
+        const codegen = new CodeGenerator({
+          target,
+          outDir,
+          jsExtension,
+          globCache
+        });
+        await content({
+          core: this,
+          codegen,
+          workspace: workspace?.name
+        });
+        return {
+          path: path4,
+          content: codegen.toString()
+        };
+      }
+    };
+    const added = /* @__PURE__ */ new Set();
+    const out = {
+      entries: [],
+      workspaces: {}
+    };
+    for (const li of await Promise.all(
+      this.plugins.map((plugin) => {
+        if (filterPlugin && !filterPlugin(plugin) || !plugin.emit)
+          return null;
+        return plugin.emit.call(ctx);
+      })
+    )) {
+      if (!li) continue;
+      for (const item of li) {
+        if (added.has(item.path)) continue;
+        out.entries.push(item);
+        added.add(item.path);
+      }
+    }
+    if (write) {
+      await Promise.all(
+        out.entries.map(async (entry) => {
+          const file = import_node_path2.default.join(outDir, entry.path);
+          await import_promises.default.mkdir(import_node_path2.default.dirname(file), { recursive: true });
+          await import_promises.default.writeFile(file, entry.content);
+        })
+      );
+      console.log(
+        workspace ? `[MDX: ${workspace.name}] generated files in ${performance.now() - start}ms` : `[MDX] generated files in ${performance.now() - start}ms`
+      );
+    }
+    await Promise.all(
+      this.workspaces.entries().map(async ([name, workspace2]) => {
+        if (filterWorkspace && !filterWorkspace(name)) return;
+        out.workspaces[name] = (await workspace2.emit(emitOptions)).entries;
+      })
+    );
+    return out;
+  }
+};
+
+// src/next/index.ts
+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 = path3.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 (path3.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
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createContent,
+  createStandaloneCore
+});