fumadocs-mdx 13.0.0 → 13.0.2

package/dist/next/index.js

@@ -1,25 +1,24 @@
-import {
-  getGlobPatterns,
-  getImportCode,
-  isFileSupported,
-  toImportPath
-} from "../chunk-6Y5JDZHD.js";
 import {
   loadConfig
 } from "../chunk-JVZFH6ND.js";
+import {
+  getImportCode,
+  toImportPath
+} from "../chunk-CXA4JO4Z.js";
 import "../chunk-U4MQ44TS.js";
 import {
   ValidationError,
+  createCore,
   findConfigFile,
   getGitTimestamp,
   validate
-} from "../chunk-HI62EXSB.js";
+} from "../chunk-EELYB2XC.js";
 import {
   fumaMatter
 } from "../chunk-VWJKRQZR.js";
 import {
-  createPluginHandler
-} from "../chunk-4MAYA5QX.js";
+  getCollectionFiles
+} from "../chunk-XZY2AWJI.js";
 
 // src/next/index.ts
 import * as path3 from "path";
@@ -52,13 +51,29 @@ function removeFileCache(file) {
 // src/plugins/next.ts
 import * as path2 from "path";
 import { createHash } from "crypto";
-import { glob } from "tinyglobby";
 import { load } from "js-yaml";
 function next() {
   let config;
+  let shouldEmitOnChange = false;
   return {
+    name: "next",
     config(v) {
       config = v;
+      shouldEmitOnChange = false;
+      for (const collection of config.collections.values()) {
+        if (collection.type === "doc" && collection.async || collection.type === "docs" && collection.docs.async) {
+          shouldEmitOnChange = true;
+        }
+      }
+    },
+    configureServer(server) {
+      if (!server.watcher) return;
+      server.watcher.on("all", async () => {
+        if (!shouldEmitOnChange) return;
+        await this.core.emitAndWrite({
+          filterPlugin: (plugin) => plugin.name === "next"
+        });
+      });
     },
     async emit() {
       return [
@@ -201,27 +216,6 @@ async function indexFile(configPath, config, importPath, configHash = false) {
     ...resolvedDeclares
   ].join("\n");
 }
-async function getCollectionFiles(collection) {
-  const files = /* @__PURE__ */ new Map();
-  const dirs = Array.isArray(collection.dir) ? collection.dir : [collection.dir];
-  const patterns = getGlobPatterns(collection);
-  await Promise.all(
-    dirs.map(async (dir) => {
-      const result = await glob(patterns, {
-        cwd: path2.resolve(dir)
-      });
-      for (const item of result) {
-        if (!isFileSupported(item, collection)) continue;
-        const fullPath = path2.join(dir, item);
-        files.set(fullPath, {
-          path: item,
-          fullPath
-        });
-      }
-    })
-  );
-  return Array.from(files.values());
-}
 function parseMetaEntry(file, content) {
   const extname2 = path2.extname(file);
   try {
@@ -289,63 +283,63 @@ function createMDX(createOptions = {}) {
   };
 }
 async function init(dev, options) {
-  const pluginHandler = createNextPluginHandler(options);
-  let config;
-  async function updateConfig() {
-    config = await pluginHandler.init(
-      await loadConfig(options.configPath, options.outDir, true)
-    );
+  const core = createNextCore(options);
+  async function initOrReload() {
+    await core.init({
+      config: loadConfig(options.configPath, options.outDir, true)
+    });
+    await core.emitAndWrite();
   }
-  async function emitFiles() {
-    const start = performance.now();
-    try {
-      await pluginHandler.emitAndWrite();
-    } catch (err) {
-      if (err instanceof ValidationError) {
-        console.error(err.toStringFormatted());
+  async function devServer() {
+    const { FSWatcher } = await import("chokidar");
+    const watcher = new FSWatcher({
+      ignoreInitial: true,
+      persistent: true,
+      ignored: [options.outDir]
+    });
+    watcher.add(options.configPath);
+    for (const collection of core.getConfig().collections.values()) {
+      if (collection.type === "docs") {
+        watcher.add(collection.docs.dir);
+        watcher.add(collection.meta.dir);
       } else {
-        console.error(err);
+        watcher.add(collection.dir);
       }
     }
-    console.log(`[MDX] updated map file in ${performance.now() - start}ms`);
-  }
-  async function devServer() {
-    const { watcher } = await import("../watcher-WXJDWRZY.js");
-    const instance = watcher(options.configPath, config, [options.outDir]);
-    async function onUpdate(event, file) {
+    watcher.on("ready", () => {
+      console.log("[MDX] started dev server");
+    });
+    watcher.on("all", async (event, file) => {
       const absolutePath = path3.resolve(file);
       if (event === "change") removeFileCache(absolutePath);
       if (absolutePath === path3.resolve(options.configPath)) {
-        await updateConfig();
+        watcher.removeAllListeners();
+        await watcher.close();
+        await initOrReload();
         console.log("[MDX] restarting dev server");
-        await instance.close();
-        void devServer();
+        await devServer();
       }
-      await emitFiles();
-    }
-    instance.on("ready", () => {
-      console.log("[MDX] started dev server");
-    });
-    instance.on("all", (event, file) => {
-      void onUpdate(event, file);
     });
     process.on("exit", () => {
+      if (watcher.closed) return;
       console.log("[MDX] closing dev server");
-      void instance.close();
+      void watcher.close();
     });
+    await core.initServer({ watcher });
+  }
+  await initOrReload();
+  if (dev) {
+    await devServer();
   }
-  await updateConfig();
-  await emitFiles();
-  if (dev) void devServer();
 }
 async function postInstall(configPath = findConfigFile(), outDir = ".source") {
-  const pluginHandler = createNextPluginHandler({
+  const core = await createNextCore({
     outDir,
     configPath
+  }).init({
+    config: loadConfig(configPath, outDir, true)
   });
-  await pluginHandler.init(await loadConfig(configPath, outDir, true));
-  await pluginHandler.emitAndWrite();
-  console.log("[MDX] types generated");
+  await core.emitAndWrite();
 }
 function applyDefaults(options) {
   return {
@@ -353,11 +347,11 @@ function applyDefaults(options) {
     configPath: options.configPath ?? findConfigFile()
   };
 }
-function createNextPluginHandler({
+function createNextCore({
   outDir,
   configPath
 }) {
-  return createPluginHandler(
+  const core = createCore(
     {
       environment: "next",
       outDir,
@@ -365,6 +359,20 @@ function createNextPluginHandler({
     },
     [next()]
   );
+  return {
+    ...core,
+    async emitAndWrite(...args) {
+      try {
+        await core.emitAndWrite(...args);
+      } catch (err) {
+        if (err instanceof ValidationError) {
+          console.error(err.toStringFormatted());
+        } else {
+          console.error(err);
+        }
+      }
+    }
+  };
 }
 export {
   createMDX,

package/dist/node/loader.cjs

@@ -230,18 +230,24 @@ function findConfigFile() {
   return import_node_path.default.resolve("source.config.ts");
 }
 function staticConfig({
-  outDir,
-  configPath,
+  core: core2,
   buildConfig: buildConfig2
 }) {
   let cached;
+  async function newConfig() {
+    const { loadConfig: loadConfig2 } = await Promise.resolve().then(() => (init_load(), load_exports));
+    await core2.init({
+      config: loadConfig2(
+        core2._options.configPath,
+        core2._options.outDir,
+        buildConfig2
+      )
+    });
+    return core2.getConfig();
+  }
   return {
     async getConfig() {
-      if (cached) return cached;
-      cached = Promise.resolve().then(() => (init_load(), load_exports)).then(
-        (mod) => mod.loadConfig(configPath, outDir, buildConfig2)
-      );
-      return cached;
+      return cached ??= newConfig();
     }
   };
 }
@@ -690,14 +696,6 @@ var cacheEntry = import_zod.z.object({
   map: import_zod.z.any().optional(),
   hash: import_zod.z.string().optional()
 });
-var hashes = /* @__PURE__ */ new WeakMap();
-function getConfigHash(config) {
-  let hash = hashes.get(config);
-  if (hash) return hash;
-  hash = Date.now().toString();
-  hashes.set(config, hash);
-  return hash;
-}
 function createMdxLoader(configLoader) {
   return async ({
     source: value,
@@ -708,14 +706,25 @@ function createMdxLoader(configLoader) {
   }) => {
     const matter = fumaMatter(value);
     const parsed = querySchema.parse(query);
-    const loaded = await configLoader.getConfig();
-    const cacheDir = isDevelopment ? void 0 : loaded.global.experimentalBuildCache;
-    const cacheKey = `${parsed.hash}_${parsed.collection ?? "global"}_${generateCacheHash(filePath)}`;
-    if (cacheDir) {
+    const config = await configLoader.getConfig();
+    let after;
+    if (!isDevelopment && config.global.experimentalBuildCache) {
+      const cacheDir = config.global.experimentalBuildCache;
+      const cacheKey = `${parsed.hash}_${parsed.collection ?? "global"}_${generateCacheHash(filePath)}`;
       const cached = await import_promises2.default.readFile(import_node_path3.default.join(cacheDir, cacheKey)).then((content) => cacheEntry.parse(JSON.parse(content.toString()))).catch(() => null);
       if (cached && cached.hash === generateCacheHash(value)) return cached;
+      after = async () => {
+        await import_promises2.default.mkdir(cacheDir, { recursive: true });
+        await import_promises2.default.writeFile(
+          import_node_path3.default.join(cacheDir, cacheKey),
+          JSON.stringify({
+            ...out,
+            hash: generateCacheHash(value)
+          })
+        );
+      };
     }
-    const collection = parsed.collection ? loaded.collections.get(parsed.collection) : void 0;
+    const collection = parsed.collection ? config.collections.get(parsed.collection) : void 0;
     let docCollection;
     switch (collection?.type) {
       case "doc":
@@ -743,16 +752,16 @@ function createMdxLoader(configLoader) {
       };
     }
     const data = {};
-    if (loaded.global.lastModifiedTime === "git") {
+    if (config.global.lastModifiedTime === "git") {
       data.lastModified = (await getGitTimestamp(filePath))?.getTime();
     }
     const lineOffset = isDevelopment ? countLines(matter.matter) : 0;
     const compiled = await buildMDX(
-      `${getConfigHash(loaded)}:${parsed.collection ?? "global"}`,
+      `${getConfigHash(config)}:${parsed.collection ?? "global"}`,
       "\n".repeat(lineOffset) + matter.content,
       {
         development: isDevelopment,
-        ...docCollection?.mdxOptions ?? await loaded.getDefaultMDXOptions(),
+        ...docCollection?.mdxOptions ?? await config.getDefaultMDXOptions(),
         postprocess: docCollection?.postprocess,
         data,
         filePath,
@@ -764,19 +773,18 @@ function createMdxLoader(configLoader) {
       code: String(compiled.value),
       map: compiled.map
     };
-    if (cacheDir) {
-      await import_promises2.default.mkdir(cacheDir, { recursive: true });
-      await import_promises2.default.writeFile(
-        import_node_path3.default.join(cacheDir, cacheKey),
-        JSON.stringify({
-          ...out,
-          hash: generateCacheHash(value)
-        })
-      );
-    }
+    await after?.();
     return out;
   };
 }
+var hashes = /* @__PURE__ */ new WeakMap();
+function getConfigHash(config) {
+  let hash = hashes.get(config);
+  if (hash) return hash;
+  hash = Date.now().toString();
+  hashes.set(config, hash);
+  return hash;
+}
 function generateCacheHash(input) {
   return (0, import_node_crypto.createHash)("md5").update(input).digest("hex");
 }
@@ -820,12 +828,89 @@ function toNode(loader, filterByPath) {
   };
 }
 
+// src/core.ts
+var import_node_path5 = __toESM(require("path"), 1);
+var import_promises4 = __toESM(require("fs/promises"), 1);
+function createCore(options, defaultPlugins = []) {
+  let config;
+  let plugins2;
+  return {
+    _options: options,
+    getPluginContext() {
+      return {
+        core: this,
+        ...options
+      };
+    },
+    /**
+     * Convenient cache store, reset when config changes
+     */
+    cache: /* @__PURE__ */ new Map(),
+    async init({ config: newConfig }) {
+      config = await newConfig;
+      this.cache.clear();
+      plugins2 = [];
+      for await (const option of [
+        ...defaultPlugins,
+        ...config.global.plugins ?? []
+      ]) {
+        if (!option) continue;
+        if (Array.isArray(option)) plugins2.push(...option);
+        else plugins2.push(option);
+      }
+      for (const plugin of plugins2) {
+        const out = await plugin.config?.call(this.getPluginContext(), config);
+        if (out) config = out;
+      }
+      return this;
+    },
+    getConfig() {
+      return config;
+    },
+    creatConfigLoader() {
+      return {
+        getConfig() {
+          return config;
+        }
+      };
+    },
+    async initServer(server) {
+      for (const plugin of plugins2) {
+        await plugin.configureServer?.call(this.getPluginContext(), server);
+      }
+    },
+    async emitAndWrite({
+      filterPlugin = () => true
+    } = {}) {
+      const start = performance.now();
+      const out = await Promise.all(
+        plugins2.map((plugin) => {
+          if (!filterPlugin(plugin) || !plugin.emit) return [];
+          return plugin.emit.call(this.getPluginContext());
+        })
+      );
+      await Promise.all(
+        out.flat().map(async (entry) => {
+          const file = import_node_path5.default.join(options.outDir, entry.path);
+          await import_promises4.default.mkdir(import_node_path5.default.dirname(file), { recursive: true });
+          await import_promises4.default.writeFile(file, entry.content);
+        })
+      );
+      console.log(`[MDX] generated files in ${performance.now() - start}ms`);
+    }
+  };
+}
+
 // src/node/loader.ts
+var core = createCore({
+  environment: "node",
+  configPath: findConfigFile(),
+  outDir: ".source"
+});
 var load2 = toNode(
   createMdxLoader(
     staticConfig({
-      configPath: findConfigFile(),
-      outDir: ".source",
+      core,
       buildConfig: true
     })
   ),

package/dist/node/loader.js

@@ -1,23 +1,28 @@
 import {
   toNode
-} from "../chunk-XV5Z4BFL.js";
+} from "../chunk-YVCR6FUH.js";
 import {
   createMdxLoader
-} from "../chunk-CEA6MYJU.js";
+} from "../chunk-XQ5O7IPO.js";
 import "../chunk-3J3WL7WN.js";
 import "../chunk-K5ZLPEIQ.js";
 import {
+  createCore,
   findConfigFile,
   staticConfig
-} from "../chunk-HI62EXSB.js";
+} from "../chunk-EELYB2XC.js";
 import "../chunk-VWJKRQZR.js";
 
 // src/node/loader.ts
+var core = createCore({
+  environment: "node",
+  configPath: findConfigFile(),
+  outDir: ".source"
+});
 var load = toNode(
   createMdxLoader(
     staticConfig({
-      configPath: findConfigFile(),
-      outDir: ".source",
+      core,
       buildConfig: true
     })
   ),

package/dist/plugins/json-schema.cjs

@@ -1,7 +1,9 @@
 "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)
@@ -15,6 +17,14 @@ var __copyProps = (to, from, except, desc) => {
   }
   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/plugins/json-schema.ts
@@ -24,17 +34,108 @@ __export(json_schema_exports, {
 });
 module.exports = __toCommonJS(json_schema_exports);
 var import_zod = require("zod");
-function jsonSchema() {
+
+// src/utils/collections.ts
+var import_picomatch = __toESM(require("picomatch"), 1);
+var import_tinyglobby = require("tinyglobby");
+var import_node_path = __toESM(require("path"), 1);
+var SupportedFormats = {
+  doc: ["mdx", "md"],
+  meta: ["json", "yaml"]
+};
+function getGlobPatterns(collection) {
+  if (collection.files) return collection.files;
+  return [`**/*.{${SupportedFormats[collection.type].join(",")}}`];
+}
+function isFileSupported(filePath, collection) {
+  return SupportedFormats[collection.type].some(
+    (format) => filePath.endsWith(`.${format}`)
+  );
+}
+function createCollectionMatcher(core) {
+  const CacheKey = "collection-matcher";
+  return {
+    scan(config) {
+      const scanned = [];
+      function scan(name, collection) {
+        const patterns = getGlobPatterns(collection);
+        for (const dir of Array.isArray(collection.dir) ? collection.dir : [collection.dir]) {
+          scanned.push({
+            name,
+            collection,
+            matcher: (0, import_picomatch.default)(patterns, {
+              cwd: dir
+            })
+          });
+        }
+      }
+      for (const [name, collection] of config.collections) {
+        if (collection.type === "docs") {
+          scan(name, collection.meta);
+          scan(name, collection.docs);
+        } else {
+          scan(name, collection);
+        }
+      }
+      return scanned;
+    },
+    getFileCollection(file) {
+      const scanned = core.cache.get(CacheKey) ?? this.scan(core.getConfig());
+      core.cache.set(CacheKey, scanned);
+      for (const item of scanned) {
+        if (isFileSupported(file, item.collection) && item.matcher(file))
+          return { name: item.name, collection: item.collection };
+      }
+    }
+  };
+}
+
+// src/plugins/json-schema.ts
+var import_promises = __toESM(require("fs/promises"), 1);
+var import_node_path2 = __toESM(require("path"), 1);
+function jsonSchema({
+  insert = false
+} = {}) {
   let config;
+  function getSchemaPath(name) {
+    return `json-schema/${name}.json`;
+  }
   return {
     config(v) {
       config = v;
     },
+    configureServer(server) {
+      if (!server.watcher || !insert) return;
+      const matcher = createCollectionMatcher(this.core);
+      server.watcher.on("add", async (file) => {
+        const match = matcher.getFileCollection(file);
+        if (!match || match.collection.type !== "meta") return;
+        const { name } = match;
+        const parent = config.collections.get(name);
+        let obj;
+        try {
+          const content = (await import_promises.default.readFile(file)).toString();
+          obj = content.length > 0 ? JSON.parse(content) : {};
+        } catch {
+          return;
+        }
+        if ("$schema" in obj) return;
+        const schemaPath = import_node_path2.default.join(
+          this.outDir,
+          getSchemaPath(parent?.type === "docs" ? `${name}.meta` : name)
+        );
+        const updated = {
+          $schema: import_node_path2.default.relative(import_node_path2.default.dirname(file), schemaPath),
+          ...obj
+        };
+        await import_promises.default.writeFile(file, JSON.stringify(updated, null, 2));
+      });
+    },
     emit() {
       const files = [];
       function onSchema(name, schema) {
         files.push({
-          path: `json-schema/${name}.json`,
+          path: getSchemaPath(name),
           content: JSON.stringify(
             import_zod.z.toJSONSchema(schema, {
               io: "input",

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

@@ -1,16 +1,24 @@
-import { P as Plugin } from '../define-BCNh3n4O.cjs';
+import { i as Plugin } from '../core-B6j6Fxse.cjs';
 import '@standard-schema/spec';
 import 'fumadocs-core/mdx-plugins';
 import '@mdx-js/mdx';
 import 'unified';
 import 'zod';
-import '../remark-postprocess-K233ZVBK.cjs';
+import 'chokidar';
 
+interface JSONSchemaOptions {
+    /**
+     * insert `$schema` field to JSON files on creation.
+     *
+     * @defaultValue false
+     */
+    insert?: boolean;
+}
 /**
  * Generate JSON schemas locally for collection schemas
  *
  * note: **it only works with Zod**
  */
-declare function jsonSchema(): Plugin;
+declare function jsonSchema({ insert, }?: JSONSchemaOptions): Plugin;
 
-export { jsonSchema as default };
+export { type JSONSchemaOptions, jsonSchema as default };

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

@@ -1,16 +1,24 @@
-import { P as Plugin } from '../define-bck_EB4t.js';
+import { i as Plugin } from '../core-B6j6Fxse.js';
 import '@standard-schema/spec';
 import 'fumadocs-core/mdx-plugins';
 import '@mdx-js/mdx';
 import 'unified';
 import 'zod';
-import '../remark-postprocess-K233ZVBK.js';
+import 'chokidar';
 
+interface JSONSchemaOptions {
+    /**
+     * insert `$schema` field to JSON files on creation.
+     *
+     * @defaultValue false
+     */
+    insert?: boolean;
+}
 /**
  * Generate JSON schemas locally for collection schemas
  *
  * note: **it only works with Zod**
  */
-declare function jsonSchema(): Plugin;
+declare function jsonSchema({ insert, }?: JSONSchemaOptions): Plugin;
 
-export { jsonSchema as default };
+export { type JSONSchemaOptions, jsonSchema as default };