fumadocs-mdx 11.6.0 → 13.0.1

package/dist/node/loader.d.cts

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

package/dist/node/loader.d.ts

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

package/dist/node/loader.js

@@ -0,0 +1,33 @@
+import {
+  toNode
+} from "../chunk-YVCR6FUH.js";
+import {
+  createMdxLoader
+} from "../chunk-XQ5O7IPO.js";
+import "../chunk-3J3WL7WN.js";
+import "../chunk-K5ZLPEIQ.js";
+import {
+  createCore,
+  findConfigFile,
+  staticConfig
+} 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({
+      core,
+      buildConfig: true
+    })
+  ),
+  (filePath) => filePath.endsWith(".md") || filePath.endsWith(".mdx")
+);
+export {
+  load
+};

package/dist/plugins/json-schema.cjs

@@ -0,0 +1,162 @@
+"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/plugins/json-schema.ts
+var json_schema_exports = {};
+__export(json_schema_exports, {
+  default: () => jsonSchema
+});
+module.exports = __toCommonJS(json_schema_exports);
+var import_zod = require("zod");
+
+// 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: getSchemaPath(name),
+          content: JSON.stringify(
+            import_zod.z.toJSONSchema(schema, {
+              io: "input",
+              unrepresentable: "any"
+            })
+          )
+        });
+      }
+      for (const [name, collection] of config.collections) {
+        if (collection.type === "docs") {
+          if (collection.meta.schema instanceof import_zod.z.ZodType) {
+            onSchema(`${name}.meta`, collection.meta.schema);
+          }
+          if (collection.docs.schema instanceof import_zod.z.ZodType) {
+            onSchema(`${name}.docs`, collection.docs.schema);
+          }
+        } else if (collection.schema instanceof import_zod.z.ZodType) {
+          onSchema(name, collection.schema);
+        }
+      }
+      return files;
+    }
+  };
+}

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

@@ -0,0 +1,24 @@
+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 '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({ insert, }?: JSONSchemaOptions): Plugin;
+
+export { type JSONSchemaOptions, jsonSchema as default };

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

@@ -0,0 +1,24 @@
+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 '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({ insert, }?: JSONSchemaOptions): Plugin;
+
+export { type JSONSchemaOptions, jsonSchema as default };

package/dist/plugins/json-schema.js

@@ -0,0 +1,78 @@
+import {
+  createCollectionMatcher
+} from "../chunk-XZY2AWJI.js";
+
+// src/plugins/json-schema.ts
+import { z } from "zod";
+import fs from "fs/promises";
+import path from "path";
+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 fs.readFile(file)).toString();
+          obj = content.length > 0 ? JSON.parse(content) : {};
+        } catch {
+          return;
+        }
+        if ("$schema" in obj) return;
+        const schemaPath = path.join(
+          this.outDir,
+          getSchemaPath(parent?.type === "docs" ? `${name}.meta` : name)
+        );
+        const updated = {
+          $schema: path.relative(path.dirname(file), schemaPath),
+          ...obj
+        };
+        await fs.writeFile(file, JSON.stringify(updated, null, 2));
+      });
+    },
+    emit() {
+      const files = [];
+      function onSchema(name, schema) {
+        files.push({
+          path: getSchemaPath(name),
+          content: JSON.stringify(
+            z.toJSONSchema(schema, {
+              io: "input",
+              unrepresentable: "any"
+            })
+          )
+        });
+      }
+      for (const [name, collection] of config.collections) {
+        if (collection.type === "docs") {
+          if (collection.meta.schema instanceof z.ZodType) {
+            onSchema(`${name}.meta`, collection.meta.schema);
+          }
+          if (collection.docs.schema instanceof z.ZodType) {
+            onSchema(`${name}.docs`, collection.docs.schema);
+          }
+        } else if (collection.schema instanceof z.ZodType) {
+          onSchema(name, collection.schema);
+        }
+      }
+      return files;
+    }
+  };
+}
+export {
+  jsonSchema as default
+};

package/dist/{mdx-options-CAU273O3.js → preset-ZMP6U62C.js}

@@ -1,6 +1,6 @@
 import {
   getDefaultMDXOptions
-} from "./chunk-IOENRFUX.js";
+} from "./chunk-FSZMKRVH.js";
 export {
   getDefaultMDXOptions
 };