fumadocs-mdx 13.0.3 → 13.0.4

package/dist/node/loader.cjs

@@ -118,35 +118,78 @@ var init_preset = __esm({
 });
 
 // src/config/build.ts
+function buildCollection(name, config) {
+  if (config.type === "docs") {
+    return {
+      ...config,
+      name,
+      meta: buildPrimitiveCollection(name, config.meta),
+      docs: buildPrimitiveCollection(name, config.docs)
+    };
+  }
+  return buildPrimitiveCollection(name, config);
+}
+function buildPrimitiveCollection(name, { files, ...config }) {
+  const supportedFormats = SupportedFormats[config.type];
+  const patterns = files ?? [`**/*.{${supportedFormats.join(",")}}`];
+  let matchers;
+  return {
+    ...config,
+    name,
+    patterns,
+    isFileSupported(filePath) {
+      return supportedFormats.some((format) => filePath.endsWith(`.${format}`));
+    },
+    hasFile(filePath) {
+      matchers ??= (Array.isArray(config.dir) ? config.dir : [config.dir]).map(
+        (dir) => (0, import_picomatch.default)(patterns, {
+          cwd: dir
+        })
+      );
+      return this.isFileSupported(filePath) && matchers.some((matcher) => matcher(filePath));
+    }
+  };
+}
 function buildConfig(config) {
   const collections = /* @__PURE__ */ new Map();
-  let globalConfig = {};
+  const loaded = {};
   for (const [k, v] of Object.entries(config)) {
     if (!v) {
       continue;
     }
     if (typeof v === "object" && "type" in v) {
       if (v.type === "docs") {
-        collections.set(k, v);
+        collections.set(k, buildCollection(k, v));
         continue;
       }
       if (v.type === "doc" || v.type === "meta") {
-        collections.set(k, v);
+        collections.set(
+          k,
+          buildCollection(k, v)
+        );
         continue;
       }
     }
     if (k === "default" && v) {
-      globalConfig = v;
+      Object.assign(loaded, v);
       continue;
     }
     throw new Error(
       `Unknown export "${k}", you can only export collections from source configuration file.`
     );
   }
+  if (loaded.collections) {
+    for (const [k, v] of Object.entries(loaded.collections)) {
+      collections.set(k, buildCollection(k, v));
+    }
+  }
   const mdxOptionsCache = /* @__PURE__ */ new Map();
   return {
-    global: globalConfig,
-    collections,
+    global: loaded,
+    collectionList: Array.from(collections.values()),
+    getCollection(name) {
+      return collections.get(name);
+    },
     async getDefaultMDXOptions(mode = "default") {
       const cached = mdxOptionsCache.get(mode);
       if (cached) return cached;
@@ -166,15 +209,21 @@ function buildConfig(config) {
     }
   };
 }
+var import_picomatch, SupportedFormats;
 var init_build = __esm({
   "src/config/build.ts"() {
     "use strict";
+    import_picomatch = __toESM(require("picomatch"), 1);
+    SupportedFormats = {
+      doc: ["mdx", "md"],
+      meta: ["json", "yaml"]
+    };
   }
 });
 
-// src/loaders/config/load.ts
-var load_exports = {};
-__export(load_exports, {
+// src/config/load-from-file.ts
+var load_from_file_exports = {};
+__export(load_from_file_exports, {
   loadConfig: () => loadConfig
 });
 async function compileConfig(configPath, outDir) {
@@ -199,19 +248,19 @@ async function compileConfig(configPath, outDir) {
 }
 async function loadConfig(configPath, outDir, build = false) {
   if (build) await compileConfig(configPath, outDir);
-  const url = (0, import_node_url.pathToFileURL)(path.resolve(outDir, "source.config.mjs"));
+  const url = (0, import_node_url2.pathToFileURL)(path6.resolve(outDir, "source.config.mjs"));
   url.searchParams.set("hash", Date.now().toString());
   const config = import(url.href).then(
     (loaded) => buildConfig(loaded)
   );
   return await config;
 }
-var path, import_node_url;
-var init_load = __esm({
-  "src/loaders/config/load.ts"() {
+var path6, import_node_url2;
+var init_load_from_file = __esm({
+  "src/config/load-from-file.ts"() {
     "use strict";
-    path = __toESM(require("path"), 1);
-    import_node_url = require("url");
+    path6 = __toESM(require("path"), 1);
+    import_node_url2 = require("url");
     init_build();
   }
 });
@@ -219,35 +268,75 @@ var init_load = __esm({
 // src/node/loader.ts
 var loader_exports = {};
 __export(loader_exports, {
-  load: () => load2
+  load: () => load3
 });
 module.exports = __toCommonJS(loader_exports);
 
-// src/loaders/config/index.ts
+// src/core.ts
 var import_node_path = __toESM(require("path"), 1);
 var import_promises = __toESM(require("fs/promises"), 1);
 function findConfigFile() {
   return import_node_path.default.resolve("source.config.ts");
 }
-function staticConfig({
-  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();
-  }
+function createCore(options, defaultPlugins = []) {
+  let config;
+  let plugins2;
   return {
-    async getConfig() {
-      return cached ??= newConfig();
+    _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;
+    },
+    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_path.default.join(options.outDir, entry.path);
+          await import_promises.default.mkdir(import_node_path.default.dirname(file), { recursive: true });
+          await import_promises.default.writeFile(file, entry.content);
+        })
+      );
+      console.log(`[MDX] generated files in ${performance.now() - start}ms`);
     }
   };
 }
@@ -335,7 +424,7 @@ var import_mdx = require("@mdx-js/mdx");
 // src/loaders/mdx/remark-include.ts
 var import_unified = require("unified");
 var import_unist_util_visit2 = require("unist-util-visit");
-var path4 = __toESM(require("path"), 1);
+var path3 = __toESM(require("path"), 1);
 var fs2 = __toESM(require("fs/promises"), 1);
 var import_mdx_plugins = require("fumadocs-core/mdx-plugins");
 
@@ -466,7 +555,7 @@ ${e instanceof Error ? e.message : String(e)}`,
         { cause: e }
       );
     }
-    const ext = path4.extname(file);
+    const ext = path3.extname(file);
     data._compiler?.addDependency(file);
     if (params.lang || ext !== ".md" && ext !== ".mdx") {
       const lang = params.lang ?? ext.slice(1);
@@ -499,7 +588,7 @@ ${e instanceof Error ? e.message : String(e)}`,
     } else {
       mdast = await baseProcessor.run(mdast);
     }
-    await update(mdast, path4.dirname(file), data);
+    await update(mdast, path3.dirname(file), data);
     return mdast;
   };
   async function update(tree, directory, data) {
@@ -511,7 +600,7 @@ ${e instanceof Error ? e.message : String(e)}`,
       if (specifier.length === 0) return "skip";
       const attributes = parseElementAttributes(node);
       const { file: relativePath, section } = parseSpecifier(specifier);
-      const file = path4.resolve(
+      const file = path3.resolve(
         "cwd" in attributes ? process.cwd() : directory,
         relativePath
       );
@@ -528,7 +617,7 @@ ${e instanceof Error ? e.message : String(e)}`,
     await Promise.all(queue);
   }
   return async (tree, file) => {
-    await update(tree, path4.dirname(file.path), file.data);
+    await update(tree, path3.dirname(file.path), file.data);
   };
 }
 
@@ -696,7 +785,7 @@ var cacheEntry = import_zod.z.object({
   map: import_zod.z.any().optional(),
   hash: import_zod.z.string().optional()
 });
-function createMdxLoader(configLoader) {
+function createMdxLoader(configLoader2) {
   return async ({
     source: value,
     development: isDevelopment,
@@ -706,7 +795,7 @@ function createMdxLoader(configLoader) {
   }) => {
     const matter = fumaMatter(value);
     const parsed = querySchema.parse(query);
-    const config = await configLoader.getConfig();
+    const config = await configLoader2.getConfig();
     let after;
     if (!isDevelopment && config.global.experimentalBuildCache) {
       const cacheDir = config.global.experimentalBuildCache;
@@ -724,7 +813,7 @@ function createMdxLoader(configLoader) {
         );
       };
     }
-    const collection = parsed.collection ? config.collections.get(parsed.collection) : void 0;
+    const collection = parsed.collection ? config.getCollection(parsed.collection) : void 0;
     let docCollection;
     switch (collection?.type) {
       case "doc":
@@ -797,16 +886,15 @@ function countLines(s) {
 }
 
 // src/loaders/adapter.ts
-var import_node_url2 = require("url");
+var import_node_url = require("url");
 var import_promises3 = __toESM(require("fs/promises"), 1);
 var import_node_querystring = require("querystring");
 var import_node_path4 = __toESM(require("path"), 1);
-function toNode(loader, filterByPath) {
+function toNode(loader, test) {
   return async (url, _context, nextLoad) => {
-    if (!url.startsWith("file:///")) return nextLoad(url);
-    const parsedUrl = new URL(url);
-    const filePath = (0, import_node_url2.fileURLToPath)(parsedUrl);
-    if (filterByPath(filePath)) {
+    if (url.startsWith("file:///") && test.test(url)) {
+      const parsedUrl = new URL(url);
+      const filePath = (0, import_node_url.fileURLToPath)(parsedUrl);
       const source = (await import_promises3.default.readFile(filePath)).toString();
       const result = await loader({
         filePath,
@@ -818,104 +906,130 @@ function toNode(loader, filterByPath) {
           }
         }
       });
-      return {
-        source: result.code,
-        format: "module",
-        shortCircuit: true
-      };
+      if (result) {
+        return {
+          source: result.code,
+          format: "module",
+          shortCircuit: true
+        };
+      }
     }
     return nextLoad(url);
   };
 }
 
-// src/core.ts
-var import_node_path5 = __toESM(require("path"), 1);
+// src/loaders/config.ts
 var import_promises4 = __toESM(require("fs/promises"), 1);
-function createCore(options, defaultPlugins = []) {
-  let config;
-  let plugins2;
+function createStandaloneConfigLoader({
+  core: core2,
+  buildConfig: buildConfig2,
+  mode
+}) {
+  let loaded;
+  async function getConfigHash2() {
+    if (mode === "production") return "static";
+    const stats = await import_promises4.default.stat(core2._options.configPath).catch(() => {
+      throw new Error("Cannot find config file");
+    });
+    return stats.mtime.getTime().toString();
+  }
+  async function newConfig() {
+    const { loadConfig: loadConfig2 } = await Promise.resolve().then(() => (init_load_from_file(), load_from_file_exports));
+    await core2.init({
+      config: loadConfig2(
+        core2._options.configPath,
+        core2._options.outDir,
+        buildConfig2
+      )
+    });
+    return core2.getConfig();
+  }
   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 getConfig() {
+      const hash = await getConfigHash2();
+      if (loaded && loaded.hash === hash) return loaded.config;
+      loaded = {
+        hash,
+        config: newConfig()
       };
-    },
-    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);
-        })
+      return loaded.config;
+    }
+  };
+}
+
+// src/loaders/meta.ts
+var import_js_yaml2 = require("js-yaml");
+var import_zod2 = require("zod");
+var querySchema2 = import_zod2.z.object({
+  collection: import_zod2.z.string().optional()
+}).loose();
+function createMetaLoader(configLoader2, resolve3 = {}) {
+  const { json: resolveJson = "js", yaml: resolveYaml = "js" } = resolve3;
+  return async ({ filePath, query, source }) => {
+    const isJson = filePath.endsWith(".json");
+    const parsed = querySchema2.parse(query);
+    const collection = parsed.collection ? (await configLoader2.getConfig()).getCollection(parsed.collection) : void 0;
+    if (!collection) return null;
+    let data;
+    try {
+      data = isJson ? JSON.parse(source) : (0, import_js_yaml2.load)(source);
+    } catch (e) {
+      throw new Error(`invalid data in ${filePath}`, { cause: e });
+    }
+    let schema;
+    switch (collection?.type) {
+      case "meta":
+        schema = collection.schema;
+        break;
+      case "docs":
+        schema = collection.meta.schema;
+        break;
+    }
+    if (schema) {
+      data = await validate(
+        schema,
+        data,
+        { path: filePath, source },
+        `invalid data in ${filePath}`
       );
-      console.log(`[MDX] generated files in ${performance.now() - start}ms`);
     }
+    let code;
+    if (isJson) {
+      code = resolveJson === "json" ? JSON.stringify(data) : `export default ${JSON.stringify(data)}`;
+    } else {
+      code = resolveYaml === "yaml" ? (0, import_js_yaml2.dump)(data) : `export default ${JSON.stringify(data)}`;
+    }
+    return {
+      code,
+      map: null
+    };
   };
 }
 
+// src/loaders/index.ts
+var metaLoaderGlob = /\.(json|yaml)(\?.+?)?$/;
+var mdxLoaderGlob = /\.mdx?(\?.+?)?$/;
+
 // src/node/loader.ts
 var core = createCore({
   environment: "node",
   configPath: findConfigFile(),
   outDir: ".source"
 });
-var load2 = toNode(
-  createMdxLoader(
-    staticConfig({
-      core,
-      buildConfig: true
-    })
-  ),
-  (filePath) => filePath.endsWith(".md") || filePath.endsWith(".mdx")
-);
+var configLoader = createStandaloneConfigLoader({
+  core,
+  buildConfig: true,
+  mode: "production"
+});
+var mdxLoader = toNode(createMdxLoader(configLoader), mdxLoaderGlob);
+var metaLoader = toNode(createMetaLoader(configLoader), metaLoaderGlob);
+var load3 = (url, context, nextLoad) => {
+  return mdxLoader(
+    url,
+    context,
+    (v, ctx) => metaLoader(v, { ...context, ...ctx }, nextLoad)
+  );
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   load

package/dist/node/loader.d.cts

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

package/dist/node/loader.d.ts

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

package/dist/node/loader.js

@@ -1,16 +1,24 @@
-import {
-  toNode
-} from "../chunk-YVCR6FUH.js";
 import {
   createMdxLoader
-} from "../chunk-XQ5O7IPO.js";
+} from "../chunk-XYGORKQA.js";
+import {
+  createMetaLoader
+} from "../chunk-YAIPHUCZ.js";
+import {
+  createStandaloneConfigLoader,
+  toNode
+} from "../chunk-ZNVPB2IR.js";
 import "../chunk-3J3WL7WN.js";
 import "../chunk-K5ZLPEIQ.js";
+import {
+  mdxLoaderGlob,
+  metaLoaderGlob
+} from "../chunk-4JSFLXXT.js";
+import "../chunk-VUEZTR2H.js";
 import {
   createCore,
-  findConfigFile,
-  staticConfig
-} from "../chunk-EELYB2XC.js";
+  findConfigFile
+} from "../chunk-TZ5EQBFW.js";
 import "../chunk-VWJKRQZR.js";
 
 // src/node/loader.ts
@@ -19,15 +27,20 @@ var core = createCore({
   configPath: findConfigFile(),
   outDir: ".source"
 });
-var load = toNode(
-  createMdxLoader(
-    staticConfig({
-      core,
-      buildConfig: true
-    })
-  ),
-  (filePath) => filePath.endsWith(".md") || filePath.endsWith(".mdx")
-);
+var configLoader = createStandaloneConfigLoader({
+  core,
+  buildConfig: true,
+  mode: "production"
+});
+var mdxLoader = toNode(createMdxLoader(configLoader), mdxLoaderGlob);
+var metaLoader = toNode(createMetaLoader(configLoader), metaLoaderGlob);
+var load = (url, context, nextLoad) => {
+  return mdxLoader(
+    url,
+    context,
+    (v, ctx) => metaLoader(v, { ...context, ...ctx }, nextLoad)
+  );
+};
 export {
   load
 };