fumadocs-mdx 14.0.4 → 14.1.1

package/dist/{build-mdx-W3233QBZ.js → build-mdx-RXJZQXGA.js}

@@ -1,7 +1,7 @@
 import {
   buildMDX
-} from "./chunk-KOPLIEVQ.js";
-import "./chunk-FBLMK4RS.js";
+} from "./chunk-7W73RILB.js";
+import "./chunk-Y7ISNZ7X.js";
 import "./chunk-VWJKRQZR.js";
 export {
   buildMDX

package/dist/bun/index.d.ts

@@ -1,10 +1,10 @@
 import { BunPlugin } from 'bun';
-import { C as CoreOptions } from '../core-C3QZSdEx.js';
+import { h as CoreOptions } from '../core-nagEel33.js';
 import '@mdx-js/mdx';
 import '@standard-schema/spec';
 import 'unified';
 import 'fumadocs-core/mdx-plugins';
-import 'zod';
+import 'fumadocs-core/source/schema';
 import 'chokidar';
 import 'vfile';
 import 'fumadocs-core/source';

package/dist/bun/index.js

@@ -1,23 +1,23 @@
 import {
   buildConfig
-} from "../chunk-6RPNS75C.js";
+} from "../chunk-OLD35ARB.js";
 import "../chunk-S7KOJHHO.js";
 import {
   createMdxLoader
-} from "../chunk-USWQVJWR.js";
+} from "../chunk-T6G5VOED.js";
 import {
   createMetaLoader
-} from "../chunk-TYJDYTKH.js";
+} from "../chunk-ZAYZWFWP.js";
 import {
   createIntegratedConfigLoader,
   toBun
-} from "../chunk-NKIL543T.js";
+} from "../chunk-WSQ23PNV.js";
 import "../chunk-4JSFLXXT.js";
 import {
   _Defaults,
   createCore
-} from "../chunk-K4KWUM3J.js";
-import "../chunk-WBIHDYMN.js";
+} from "../chunk-KWSETXYC.js";
+import "../chunk-2PY3JUIC.js";
 import "../chunk-VWJKRQZR.js";
 
 // src/bun/index.ts

package/dist/{chunk-CGGDM5F3.js → chunk-257RZJEQ.js}

@@ -1,6 +1,6 @@
 import {
   createCore
-} from "./chunk-K4KWUM3J.js";
+} from "./chunk-KWSETXYC.js";
 
 // src/webpack/index.ts
 var core;

package/dist/{chunk-WBIHDYMN.js → chunk-2PY3JUIC.js}

@@ -65,7 +65,7 @@ function createCodegen({
         const fullPath = path.join(base, item);
         const searchParams = new URLSearchParams();
         for (const [k, v] of Object.entries(query)) {
-          searchParams.set(k, v);
+          if (v !== void 0) searchParams.set(k, v);
         }
         const importPath = this.formatImportPath(fullPath) + "?" + searchParams.toString();
         if (eager) {
@@ -88,10 +88,9 @@ function createCodegen({
     formatImportPath(file) {
       const ext = path.extname(file);
       let filename;
-      if (ext === ".ts" && jsExtension) {
-        filename = file.substring(0, file.length - ext.length) + ".js";
-      } else if (ext === ".ts") {
+      if (ext === ".ts") {
         filename = file.substring(0, file.length - ext.length);
+        if (jsExtension) filename += ".js";
       } else {
         filename = file;
       }
@@ -122,5 +121,6 @@ function ident(code, tab = 1) {
 
 export {
   createCodegen,
+  slash,
   ident
 };

package/dist/{chunk-KOPLIEVQ.js → chunk-7W73RILB.js}

@@ -1,7 +1,7 @@
 import {
   flattenNode,
   remarkInclude
-} from "./chunk-FBLMK4RS.js";
+} from "./chunk-Y7ISNZ7X.js";
 
 // src/loaders/mdx/build-mdx.ts
 import { createProcessor } from "@mdx-js/mdx";
@@ -159,6 +159,7 @@ async function buildMDX(core, collection, {
   let vfile = new VFile({
     value: source,
     path: filePath,
+    cwd: collection?.cwd,
     data: { frontmatter, _compiler, _getProcessor: getProcessor }
   });
   if (collection) {

package/dist/{chunk-LPX7ZO66.js → chunk-DTFUANSF.js}

@@ -1,6 +1,6 @@
 import {
   buildConfig
-} from "./chunk-6RPNS75C.js";
+} from "./chunk-OLD35ARB.js";
 
 // src/config/load-from-file.ts
 import { pathToFileURL } from "url";

package/dist/{chunk-K4KWUM3J.js → chunk-KWSETXYC.js}

@@ -1,6 +1,6 @@
 import {
   ident
-} from "./chunk-WBIHDYMN.js";
+} from "./chunk-2PY3JUIC.js";
 
 // src/utils/validation.ts
 var ValidationError = class extends Error {
@@ -57,9 +57,10 @@ async function getPlugins(pluginOptions) {
   }
   return plugins;
 }
-function createCore(options, defaultPlugins = []) {
+function createCore(options) {
   let config;
   let plugins;
+  const workspaces = /* @__PURE__ */ new Map();
   async function transformMetadata({
     collection,
     filePath,
@@ -75,7 +76,7 @@ function createCore(options, defaultPlugins = []) {
     }
     return data;
   }
-  const core = {
+  return {
     /**
      * Convenient cache store, reset when config changes
      */
@@ -83,15 +84,36 @@ function createCore(options, defaultPlugins = []) {
     async init({ config: newConfig }) {
       config = await newConfig;
       this.cache.clear();
+      workspaces.clear();
       plugins = await getPlugins([
         postprocessPlugin(),
-        ...defaultPlugins,
-        ...config.global.plugins ?? []
+        options.plugins,
+        config.global.plugins
       ]);
       for (const plugin of plugins) {
-        const out = await plugin.config?.call(pluginContext, config);
+        const out = await plugin.config?.call(this.getPluginContext(), config);
         if (out) config = out;
       }
+      if (!options.workspace) {
+        await Promise.all(
+          Object.entries(config.workspaces).map(async ([name, workspace]) => {
+            const core = createCore({
+              ...options,
+              outDir: path.join(options.outDir, name),
+              workspace: {
+                name,
+                parent: this,
+                dir: workspace.dir
+              }
+            });
+            await core.init({ config: workspace.config });
+            workspaces.set(name, core);
+          })
+        );
+      }
+    },
+    getWorkspaces() {
+      return workspaces;
     },
     getOptions() {
       return options;
@@ -108,37 +130,69 @@ function createCore(options, defaultPlugins = []) {
     getPlugins() {
       return plugins;
     },
+    getCollections() {
+      return Array.from(config.collections.values());
+    },
+    getCollection(name) {
+      return config.collections.get(name);
+    },
     getPluginContext() {
-      return pluginContext;
+      return {
+        core: this
+      };
     },
     async initServer(server) {
+      const ctx = this.getPluginContext();
       for (const plugin of plugins) {
-        await plugin.configureServer?.call(pluginContext, server);
+        await plugin.configureServer?.call(ctx, server);
+      }
+      for (const workspace of workspaces.values()) {
+        await workspace.initServer(server);
       }
     },
-    async emit({ filterPlugin = () => true } = {}) {
-      return (await Promise.all(
-        plugins.map((plugin) => {
-          if (!filterPlugin(plugin) || !plugin.emit) return [];
-          return plugin.emit.call(pluginContext);
-        })
-      )).flat();
-    },
-    async emitAndWrite(emitOptions) {
+    async emit(emitOptions = {}) {
+      const { filterPlugin, filterWorkspace, write = false } = emitOptions;
       const start = performance.now();
-      const out = await this.emit(emitOptions);
-      await Promise.all(
-        out.map(async (entry) => {
-          const file = path.join(options.outDir, entry.path);
-          await fs.mkdir(path.dirname(file), { recursive: true });
-          await fs.writeFile(file, entry.content);
+      const ctx = this.getPluginContext();
+      const added = /* @__PURE__ */ new Set();
+      const out = {
+        entries: [],
+        workspaces: {}
+      };
+      for (const li of await Promise.all(
+        plugins.map((plugin) => {
+          if (filterPlugin && !filterPlugin(plugin) || !plugin.emit) return;
+          return plugin.emit.call(ctx);
         })
-      );
-      console.log(`[MDX] generated files in ${performance.now() - start}ms`);
+      )) {
+        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 = path.join(options.outDir, entry.path);
+            await fs.mkdir(path.dirname(file), { recursive: true });
+            await fs.writeFile(file, entry.content);
+          })
+        );
+        console.log(
+          options.workspace ? `[MDX: ${options.workspace.name}] generated files in ${performance.now() - start}ms` : `[MDX] generated files in ${performance.now() - start}ms`
+        );
+      }
+      for (const [name, workspace] of workspaces) {
+        if (filterWorkspace && !filterWorkspace(name)) continue;
+        out.workspaces[name] = (await workspace.emit(emitOptions)).entries;
+      }
+      return out;
     },
     async transformMeta(options2, data) {
       const ctx = {
-        ...pluginContext,
+        ...this.getPluginContext(),
         ...options2
       };
       data = await transformMetadata(options2, data);
@@ -150,7 +204,7 @@ function createCore(options, defaultPlugins = []) {
     },
     async transformFrontmatter(options2, data) {
       const ctx = {
-        ...pluginContext,
+        ...this.getPluginContext(),
         ...options2
       };
       data = await transformMetadata(options2, data);
@@ -162,7 +216,7 @@ function createCore(options, defaultPlugins = []) {
     },
     async transformVFile(options2, file) {
       const ctx = {
-        ...pluginContext,
+        ...this.getPluginContext(),
         ...options2
       };
       for (const plugin of plugins) {
@@ -172,11 +226,6 @@ function createCore(options, defaultPlugins = []) {
       return file;
     }
   };
-  const pluginContext = {
-    core,
-    ...options
-  };
-  return core;
 }
 function postprocessPlugin() {
   const LinkReferenceTypes = `{
@@ -191,7 +240,7 @@ function postprocessPlugin() {
         const lines = [];
         lines.push("{");
         lines.push("  DocData: {");
-        for (const collection of this.core.getConfig().collectionList) {
+        for (const collection of this.core.getCollections()) {
           let postprocessOptions;
           switch (collection.type) {
             case "doc":

package/dist/{chunk-6RPNS75C.js → chunk-OLD35ARB.js}

@@ -4,46 +4,57 @@ import {
 
 // src/config/build.ts
 import picomatch from "picomatch";
+import path from "path";
 var SupportedFormats = {
   doc: ["mdx", "md"],
   meta: ["json", "yaml"]
 };
-function buildCollection(name, config) {
-  if (config.type === "docs") {
+function buildCollection(name, collection, cwd) {
+  if (collection.type === "docs") {
     return {
-      ...config,
+      ...collection,
+      type: "docs",
+      get dir() {
+        return this.docs.dir;
+      },
       name,
-      meta: buildPrimitiveCollection(name, config.meta),
-      docs: buildPrimitiveCollection(name, config.docs),
+      meta: buildCollection(name, collection.meta, cwd),
+      docs: buildCollection(name, collection.docs, cwd),
       hasFile(filePath) {
         return this.docs.hasFile(filePath) || this.meta.hasFile(filePath);
-      }
+      },
+      isFileSupported(filePath) {
+        return this.docs.isFileSupported(filePath) || this.meta.isFileSupported(filePath);
+      },
+      cwd
     };
   }
-  return buildPrimitiveCollection(name, config);
+  return {
+    ...collection,
+    ...buildPrimitiveCollection(name, collection, cwd)
+  };
 }
-function buildPrimitiveCollection(name, { files, ...config }) {
+function buildPrimitiveCollection(name, config, cwd) {
   const supportedFormats = SupportedFormats[config.type];
-  const patterns = files ?? [`**/*.{${supportedFormats.join(",")}}`];
-  let matchers;
+  const patterns = config.files ?? [`**/*.{${supportedFormats.join(",")}}`];
+  let matcher;
   return {
-    ...config,
+    dir: path.resolve(cwd, config.dir),
+    cwd,
     name,
     patterns,
     isFileSupported(filePath) {
       return supportedFormats.some((format) => filePath.endsWith(`.${format}`));
     },
     hasFile(filePath) {
-      matchers ??= (Array.isArray(config.dir) ? config.dir : [config.dir]).map(
-        (dir) => picomatch(patterns, {
-          cwd: dir
-        })
-      );
-      return this.isFileSupported(filePath) && matchers.some((matcher) => matcher(filePath));
+      if (!this.isFileSupported(filePath)) return false;
+      const relativePath = path.relative(this.dir, filePath);
+      if (relativePath.startsWith(`..${path.sep}`)) return false;
+      return (matcher ??= picomatch(patterns))(relativePath);
     }
   };
 }
-function buildConfig(config) {
+function buildConfig(config, cwd = process.cwd()) {
   const collections = /* @__PURE__ */ new Map();
   const loaded = {};
   for (const [k, v] of Object.entries(config)) {
@@ -51,15 +62,8 @@ function buildConfig(config) {
       continue;
     }
     if (typeof v === "object" && "type" in v) {
-      if (v.type === "docs") {
-        collections.set(k, buildCollection(k, v));
-        continue;
-      }
-      if (v.type === "doc" || v.type === "meta") {
-        collections.set(
-          k,
-          buildCollection(k, v)
-        );
+      if (v.type === "docs" || v.type === "doc" || v.type === "meta") {
+        collections.set(k, buildCollection(k, v, cwd));
         continue;
       }
     }
@@ -74,10 +78,18 @@ function buildConfig(config) {
   const mdxOptionsCache = /* @__PURE__ */ new Map();
   return {
     global: loaded,
-    collectionList: Array.from(collections.values()),
-    getCollection(name) {
-      return collections.get(name);
-    },
+    collections,
+    workspaces: Object.fromEntries(
+      Object.entries(loaded.workspaces ?? {}).map(([key, value]) => {
+        return [
+          key,
+          {
+            dir: value.dir,
+            config: buildConfig(value.config, path.resolve(cwd, value.dir))
+          }
+        ];
+      })
+    ),
     getMDXOptions(collection, environment = "bundler") {
       const key = collection ? `${environment}:${collection.name}` : environment;
       const cached = mdxOptionsCache.get(key);