fumadocs-mdx 9.0.4 → 10.0.1

package/dist/next/index.mjs

@@ -0,0 +1,239 @@
+import {
+  findConfigFile,
+  getConfigHash,
+  getTypeFromPath,
+  loadConfig,
+  loadConfigCached,
+  writeManifest
+} from "../chunk-P6WKCOD5.mjs";
+
+// src/next/create.ts
+import path3 from "node:path";
+
+// src/map/index.ts
+import path2 from "node:path";
+import fs from "node:fs";
+
+// src/map/watcher.ts
+import { watch } from "chokidar";
+function watcher(configPath, config) {
+  const deps = [configPath];
+  for (const collection of config.collections.values()) {
+    if (Array.isArray(collection.dir)) deps.push(...collection.dir);
+    else deps.push(collection.dir);
+  }
+  return watch(deps, {
+    ignoreInitial: true
+  });
+}
+
+// src/map/generate.ts
+import path from "node:path";
+import fg from "fast-glob";
+async function generateJS(configPath, config, outputPath, hash) {
+  const outDir2 = path.dirname(outputPath);
+  const imports = ['import { toRuntime } from "fumadocs-mdx"'];
+  const importedCollections = /* @__PURE__ */ new Set();
+  const sources = [];
+  let importId = 0;
+  config._runtime.files.clear();
+  await Promise.all(
+    Array.from(config.collections.entries()).map(async ([name, collection]) => {
+      const entries = [];
+      const dirs = Array.isArray(collection.dir) ? collection.dir : [collection.dir];
+      await Promise.all(
+        dirs.map(async (dir) => {
+          const included = await fg(collection.files ?? ["**/*"], {
+            cwd: dir,
+            absolute: true
+          });
+          for (const file of included) {
+            if (getTypeFromPath(file) !== collection.type) continue;
+            if (config._runtime.files.has(file)) {
+              console.warn(
+                `[MDX] Files cannot exist in multiple collections: ${file} (${config._runtime.files.get(file) ?? ""})`
+              );
+              continue;
+            }
+            config._runtime.files.set(file, name);
+            const importName = `file_${(importId++).toString()}`;
+            imports.push(
+              `import * as ${importName} from ${JSON.stringify(`${toImportPath(file, outDir2)}?collection=${name}&hash=${hash}`)}`
+            );
+            const info = {
+              path: path.relative(dir, file),
+              absolutePath: file
+            };
+            entries.push(
+              `toRuntime("${collection.type}", ${importName}, ${JSON.stringify(info)})`
+            );
+          }
+        })
+      );
+      if (collection.transform) {
+        if (config.global) importedCollections.add("default");
+        importedCollections.add(name);
+        sources.push(
+          `export const ${name} = await Promise.all([${entries.join(",")}].map(v => c_${name}.transform(v, c_default)))`
+        );
+      } else {
+        sources.push(`export const ${name} = [${entries.join(",")}]`);
+      }
+    })
+  );
+  if (importedCollections.size > 0) {
+    imports.push(
+      `import { ${Array.from(importedCollections.values()).map((v) => `${v} as c_${v}`).join(
+        ", "
+      )} } from ${JSON.stringify(toImportPath(configPath, outDir2))}`
+    );
+  }
+  return [...imports, ...sources].join("\n");
+}
+function toImportPath(file, dir) {
+  let importPath = path.relative(dir, file);
+  if (!path.isAbsolute(importPath) && !importPath.startsWith(".")) {
+    importPath = `./${importPath}`;
+  }
+  return importPath.replaceAll(path.sep, "/");
+}
+function generateTypes(configPath, config, outputPath) {
+  const importPath = JSON.stringify(
+    toImportPath(configPath, path.dirname(outputPath))
+  );
+  const lines = [
+    'import type { GetOutput } from "fumadocs-mdx/config"'
+  ];
+  for (const name of config.collections.keys()) {
+    lines.push(
+      `export declare const ${name}: GetOutput<typeof import(${importPath}).${name}>`
+    );
+  }
+  return lines.join("\n");
+}
+
+// src/map/index.ts
+async function start(dev, configPath, outDir2) {
+  let configHash = await getConfigHash(configPath);
+  let config = await loadConfigCached(configPath, configHash);
+  const manifestPath = path2.resolve(outDir2, "manifest.json");
+  const jsOut = path2.resolve(outDir2, `index.js`);
+  const typeOut = path2.resolve(outDir2, `index.d.ts`);
+  if (dev) {
+    const instance = watcher(configPath, config);
+    instance.on("ready", () => {
+      console.log("[MDX] started dev server");
+    });
+    instance.on("all", (event, file) => {
+      const onUpdate = async () => {
+        const isConfigFile = path2.resolve(file) === configPath;
+        if (isConfigFile) {
+          configHash = await getConfigHash(configPath);
+          config = await loadConfigCached(configPath, configHash);
+          fs.writeFileSync(typeOut, generateTypes(configPath, config, typeOut));
+          console.log("[MDX] Updated map types");
+        }
+        if (isConfigFile || event !== "change") {
+          fs.writeFileSync(
+            jsOut,
+            await generateJS(configPath, config, jsOut, configHash)
+          );
+          console.log("[MDX] Updated map file");
+        }
+      };
+      void onUpdate();
+    });
+    process.on("exit", () => {
+      console.log("[MDX] closing dev server");
+      void instance.close();
+    });
+  }
+  fs.mkdirSync(outDir2, { recursive: true });
+  fs.writeFileSync(
+    jsOut,
+    await generateJS(configPath, config, jsOut, configHash)
+  );
+  fs.writeFileSync(typeOut, generateTypes(configPath, config, typeOut));
+  console.log("[MDX] initialized map file");
+  if (config.global?.generateManifest && !dev) {
+    process.on("exit", () => {
+      console.log("[MDX] writing manifest");
+      writeManifest(manifestPath, config);
+    });
+  }
+}
+
+// src/next/create.ts
+var outDir = path3.resolve(".source");
+var defaultPageExtensions = ["mdx", "md", "jsx", "js", "tsx", "ts"];
+function createMDX({
+  configPath = findConfigFile()
+} = {}) {
+  const isDev = process.argv.includes("dev");
+  const isBuild = process.argv.includes("build");
+  if (isDev || isBuild) {
+    void start(isDev, configPath, outDir);
+  }
+  return (nextConfig = {}) => {
+    const mdxLoaderOptions = {
+      _ctx: {
+        configPath
+      }
+    };
+    return {
+      ...nextConfig,
+      experimental: {
+        ...nextConfig.experimental,
+        turbo: {
+          ...nextConfig.experimental?.turbo,
+          rules: {
+            ...nextConfig.experimental?.turbo?.rules,
+            // @ts-expect-error -- safe types
+            "*.{md,mdx}": {
+              loaders: [
+                {
+                  loader: "fumadocs-mdx/loader-mdx",
+                  options: mdxLoaderOptions
+                }
+              ],
+              as: "*.js"
+            }
+          }
+        }
+      },
+      pageExtensions: nextConfig.pageExtensions ?? defaultPageExtensions,
+      webpack: (config, options) => {
+        config.resolve ||= {};
+        config.module ||= {};
+        config.module.rules ||= [];
+        config.module.rules.push({
+          test: /\.mdx?$/,
+          use: [
+            options.defaultLoaders.babel,
+            {
+              loader: "fumadocs-mdx/loader-mdx",
+              options: mdxLoaderOptions
+            }
+          ]
+        });
+        config.plugins ||= [];
+        return nextConfig.webpack?.(config, options) ?? config;
+      }
+    };
+  };
+}
+
+// src/postinstall.ts
+import path4 from "node:path";
+import fs2 from "node:fs";
+async function postInstall(configPath = findConfigFile()) {
+  const typeOut = path4.resolve(".source/index.d.ts");
+  const config = await loadConfig(configPath);
+  fs2.mkdirSync(path4.dirname(typeOut), { recursive: true });
+  fs2.writeFileSync(typeOut, generateTypes(configPath, config, typeOut));
+  console.log("[MDX] types generated");
+}
+export {
+  createMDX,
+  postInstall
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fumadocs-mdx",
-  "version": "9.0.4",
+  "version": "10.0.1",
   "description": "The built-in source for Fumadocs",
   "keywords": [
     "NextJs",
@@ -11,11 +11,14 @@
   "license": "MIT",
   "author": "Fuma Nama",
   "exports": {
-    "./loader": "./loader.js",
     "./loader-mdx": "./loader-mdx.js",
     "./config": {
-      "import": "./dist/config.mjs",
-      "types": "./dist/config.d.mts"
+      "import": "./dist/config/index.mjs",
+      "types": "./dist/config/index.d.mts"
+    },
+    "./next": {
+      "import": "./dist/next/index.mjs",
+      "types": "./dist/next/index.d.mts"
     },
     ".": {
       "import": "./dist/index.mjs",
@@ -27,33 +30,41 @@
   "typesVersions": {
     "*": {
       "config": [
-        "./dist/config.d.mts"
+        "./dist/config/index.d.mts"
+      ],
+      "next": [
+        "./dist/next/index.d.mts"
       ]
     }
   },
+  "bin": "./bin.mjs",
   "files": [
     "dist/*",
     "loader-mdx.js",
-    "loader.js"
+    "bin.mjs"
   ],
   "dependencies": {
     "@mdx-js/mdx": "^3.0.1",
+    "chokidar": "^3.6.0",
     "cross-spawn": "^7.0.3",
+    "esbuild": "^0.23.1",
     "estree-util-value-to-estree": "^3.1.2",
     "fast-glob": "^3.3.1",
     "gray-matter": "^4.0.3",
+    "micromatch": "^4.0.8",
     "zod": "^3.23.8"
   },
   "devDependencies": {
     "@types/cross-spawn": "^6.0.6",
     "@types/mdast": "^4.0.3",
     "@types/mdx": "^2.0.13",
-    "@types/react": "^18.3.3",
-    "next": "^14.2.5",
+    "@types/micromatch": "^4.0.9",
+    "@types/react": "^18.3.5",
+    "next": "^14.2.7",
     "unified": "^11.0.5",
     "webpack": "^5.90.3",
     "eslint-config-custom": "0.0.0",
-    "fumadocs-core": "13.4.1",
+    "fumadocs-core": "13.4.5",
     "tsconfig": "0.0.0"
   },
   "peerDependencies": {

package/dist/config.d.mts

@@ -1,45 +0,0 @@
-import { NextConfig } from 'next';
-import { StructureOptions, RemarkHeadingOptions, RemarkImageOptions, RehypeCodeOptions } from 'fumadocs-core/mdx-plugins';
-import { Pluggable } from 'unified';
-import { Options as Options$1 } from './loader-mdx.mjs';
-import { O as Options } from './search-index-plugin-DG9nZ1CX.mjs';
-import '@mdx-js/mdx';
-import 'webpack';
-
-type MDXOptions = Omit<NonNullable<Options$1>, 'rehypePlugins' | 'remarkPlugins'> & {
-    rehypePlugins?: ResolvePlugins;
-    remarkPlugins?: ResolvePlugins;
-    /**
-     * Properties to export from `vfile.data`
-     */
-    valueToExport?: string[];
-    remarkStructureOptions?: StructureOptions | false;
-    remarkHeadingOptions?: RemarkHeadingOptions;
-    remarkImageOptions?: RemarkImageOptions | false;
-    rehypeCodeOptions?: RehypeCodeOptions | false;
-};
-type ResolvePlugins = Pluggable[] | ((v: Pluggable[]) => Pluggable[]);
-interface CreateMDXOptions {
-    cwd?: string;
-    mdxOptions?: MDXOptions;
-    buildSearchIndex?: Omit<Options, 'rootContentDir' | 'rootMapFile'> | boolean;
-    /**
-     * Where the root map.ts should be, relative to cwd
-     *
-     * @defaultValue `'./.map.ts'`
-     */
-    rootMapPath?: string;
-    /**
-     * Where the content directory should be, relative to cwd
-     *
-     * @defaultValue `'./content'`
-     */
-    rootContentPath?: string;
-    /**
-     * {@link LoaderOptions.include}
-     */
-    include?: string | string[];
-}
-declare function createMDX({ mdxOptions, cwd, rootMapPath, rootContentPath, buildSearchIndex, ...loadOptions }?: CreateMDXOptions): (nextConfig?: NextConfig) => NextConfig;
-
-export { type CreateMDXOptions, createMDX as default };

package/dist/config.mjs

@@ -1,264 +0,0 @@
-// src/config.ts
-import path2 from "node:path";
-import {
-  rehypeCode,
-  remarkGfm,
-  remarkStructure,
-  remarkHeading,
-  remarkImage
-} from "fumadocs-core/mdx-plugins";
-
-// src/webpack-plugins/map-plugin.ts
-import * as fs from "node:fs";
-var firstLoad = true;
-var content = `
-/** Auto-generated **/
-declare const map: Record<string, unknown>
-
-export { map }
-`.trim();
-var MapWebpackPlugin = class _MapWebpackPlugin {
-  constructor(options) {
-    this.options = options;
-  }
-  apply(compiler) {
-    const logger = compiler.getInfrastructureLogger(_MapWebpackPlugin.name);
-    compiler.hooks.beforeCompile.tap(_MapWebpackPlugin.name, () => {
-      if (firstLoad && !fs.existsSync(this.options.rootMapFile)) {
-        fs.writeFileSync(this.options.rootMapFile, content);
-        logger.info("Created map.ts file for you automatically");
-        firstLoad = false;
-      }
-    });
-  }
-};
-
-// src/mdx-plugins/utils.ts
-import { valueToEstree } from "estree-util-value-to-estree";
-function getMdastExport(name, value) {
-  return {
-    type: "mdxjsEsm",
-    value: "",
-    data: {
-      estree: {
-        type: "Program",
-        sourceType: "module",
-        body: [
-          {
-            type: "ExportNamedDeclaration",
-            specifiers: [],
-            source: null,
-            declaration: {
-              type: "VariableDeclaration",
-              kind: "let",
-              declarations: [
-                {
-                  type: "VariableDeclarator",
-                  id: {
-                    type: "Identifier",
-                    name
-                  },
-                  init: valueToEstree(value)
-                }
-              ]
-            }
-          }
-        ]
-      }
-    }
-  };
-}
-
-// src/mdx-plugins/remark-exports.ts
-function remarkMdxExport({ values }) {
-  return (tree, vfile) => {
-    for (const name of values) {
-      if (!(name in vfile.data)) return;
-      tree.children.unshift(getMdastExport(name, vfile.data[name]));
-    }
-  };
-}
-
-// src/webpack-plugins/search-index-plugin.ts
-import * as path from "node:path";
-import { createRequire } from "node:module";
-import { createGetUrl, getSlugs, parseFilePath } from "fumadocs-core/source";
-var require2 = createRequire(import.meta.url);
-var pkg = require2("next/dist/compiled/webpack/webpack.js");
-var SearchIndexPlugin = class _SearchIndexPlugin {
-  constructor(options) {
-    this.options = options;
-  }
-  apply(compiler) {
-    const {
-      rootContentDir,
-      productionOnly = true,
-      filter = () => true,
-      getUrl = (file) => {
-        return createGetUrl("/")(getSlugs(parseFilePath(file)));
-      }
-    } = this.options;
-    const logger = compiler.getInfrastructureLogger(_SearchIndexPlugin.name);
-    const isProduction = process.env.NODE_ENV === "production";
-    if (productionOnly && !isProduction) return;
-    compiler.hooks.compilation.tap(_SearchIndexPlugin.name, (compilation) => {
-      if (compilation.name !== "server") return;
-      compilation.hooks.processAssets.tap(
-        {
-          name: _SearchIndexPlugin.name,
-          stage: pkg.webpack.Compilation.PROCESS_ASSETS_STAGE_ADDITIONS
-        },
-        () => {
-          const indexFiles = /* @__PURE__ */ new Map();
-          for (const m of compilation.modules.values()) {
-            if (!m.buildInfo || !("__fumadocs" in m.buildInfo)) continue;
-            const info = m.buildInfo.__fumadocs;
-            const relativePath = path.relative(rootContentDir, info.path);
-            if (relativePath.startsWith("../") || !filter(relativePath))
-              continue;
-            indexFiles.set(info.path, {
-              id: info.path,
-              structuredData: info.data.structuredData,
-              title: info.data.frontmatter.title,
-              description: info.data.frontmatter.description,
-              url: getUrl(relativePath),
-              _data: info.data
-            });
-          }
-          compilation.emitAsset(
-            "fumadocs_search.json",
-            new pkg.sources.RawSource(
-              JSON.stringify(Array.from(indexFiles.values()))
-            )
-          );
-          logger.info("Generated Search Indexes");
-        }
-      );
-    });
-  }
-};
-
-// src/config.ts
-function pluginOption(def, options = []) {
-  const list = def(Array.isArray(options) ? options : []).filter(
-    Boolean
-  );
-  if (typeof options === "function") {
-    return options(list);
-  }
-  return list;
-}
-function getMDXLoaderOptions({
-  valueToExport = [],
-  rehypeCodeOptions,
-  remarkImageOptions,
-  remarkHeadingOptions,
-  remarkStructureOptions,
-  ...mdxOptions
-}) {
-  const mdxExports = [
-    "structuredData",
-    "toc",
-    "frontmatter",
-    "lastModified",
-    ...valueToExport
-  ];
-  const remarkPlugins = pluginOption(
-    (v) => [
-      remarkGfm,
-      [remarkHeading, remarkHeadingOptions],
-      remarkImageOptions !== false && [remarkImage, remarkImageOptions],
-      ...v,
-      remarkStructureOptions !== false && [
-        remarkStructure,
-        remarkStructureOptions
-      ],
-      [remarkMdxExport, { values: mdxExports }]
-    ],
-    mdxOptions.remarkPlugins
-  );
-  const rehypePlugins = pluginOption(
-    (v) => [
-      rehypeCodeOptions !== false && [rehypeCode, rehypeCodeOptions],
-      ...v
-    ],
-    mdxOptions.rehypePlugins
-  );
-  return {
-    providerImportSource: "next-mdx-import-source-file",
-    ...mdxOptions,
-    remarkPlugins,
-    rehypePlugins
-  };
-}
-var defaultPageExtensions = ["mdx", "md", "jsx", "js", "tsx", "ts"];
-function createMDX({
-  mdxOptions = {},
-  cwd = process.cwd(),
-  rootMapPath = "./.map.ts",
-  rootContentPath = "./content",
-  buildSearchIndex = false,
-  ...loadOptions
-} = {}) {
-  const rootMapFile = path2.resolve(cwd, rootMapPath);
-  const rootContentDir = path2.resolve(cwd, rootContentPath);
-  const mdxLoaderOptions = getMDXLoaderOptions(mdxOptions);
-  return (nextConfig = {}) => {
-    return {
-      ...nextConfig,
-      pageExtensions: nextConfig.pageExtensions ?? defaultPageExtensions,
-      webpack: (config, options) => {
-        config.resolve ||= {};
-        const alias = config.resolve.alias;
-        alias["next-mdx-import-source-file"] = [
-          "private-next-root-dir/src/mdx-components",
-          "private-next-root-dir/mdx-components",
-          "@mdx-js/react"
-        ];
-        config.module ||= {};
-        config.module.rules ||= [];
-        config.module.rules.push(
-          {
-            test: /\.mdx?$/,
-            use: [
-              options.defaultLoaders.babel,
-              {
-                loader: "fumadocs-mdx/loader-mdx",
-                options: mdxLoaderOptions
-              }
-            ]
-          },
-          {
-            test: rootMapFile,
-            use: {
-              loader: "fumadocs-mdx/loader",
-              options: {
-                rootContentDir,
-                rootMapFile,
-                ...loadOptions
-              }
-            }
-          }
-        );
-        config.plugins ||= [];
-        config.plugins.push(
-          new MapWebpackPlugin({
-            rootMapFile
-          })
-        );
-        if (buildSearchIndex !== false)
-          config.plugins.push(
-            new SearchIndexPlugin({
-              rootContentDir,
-              rootMapFile,
-              ...typeof buildSearchIndex === "object" ? buildSearchIndex : {}
-            })
-          );
-        return nextConfig.webpack?.(config, options) ?? config;
-      }
-    };
-  };
-}
-export {
-  createMDX as default
-};

package/dist/loader.d.mts

@@ -1,18 +0,0 @@
-import { LoaderContext } from 'webpack';
-
-interface LoaderOptions {
-    rootContentDir: string;
-    rootMapFile: string;
-    /**
-     * Included files in the map file
-     *
-     * @defaultValue './**/*.{md,mdx,json}'
-     */
-    include?: string | string[];
-}
-/**
- * Load the root `.map.ts` file
- */
-declare function loader(this: LoaderContext<LoaderOptions>, _source: string, callback: LoaderContext<LoaderOptions>['callback']): void;
-
-export { type LoaderOptions, loader as default };

package/dist/loader.mjs

@@ -1,36 +0,0 @@
-// src/loader.ts
-import path from "node:path";
-import fg from "fast-glob";
-function loader(_source, callback) {
-  const options = this.getOptions();
-  this.cacheable(true);
-  this.addContextDependency(options.rootContentDir);
-  callback(null, buildMap(options));
-}
-function buildMap({
-  rootContentDir,
-  rootMapFile,
-  include = ["./**/*.{md,mdx,json}"]
-}) {
-  const mapDir = path.dirname(rootMapFile);
-  const files = fg.sync(include, {
-    cwd: rootContentDir
-  });
-  const imports = [];
-  const entries = [];
-  files.forEach((file, i) => {
-    let importPath = path.relative(mapDir, path.join(rootContentDir, file)).replaceAll(path.sep, "/");
-    if (!importPath.startsWith(".")) {
-      importPath = `./${importPath}`;
-    }
-    const name = `file_${i.toString()}`;
-    imports.push(`import * as ${name} from ${JSON.stringify(importPath)};`);
-    entries.push(`${JSON.stringify(file)}: ${name}`);
-  });
-  return [imports.join("\n"), `export const map = {${entries.join(",")}}`].join(
-    "\n"
-  );
-}
-export {
-  loader as default
-};