fumadocs-mdx 14.2.2 → 14.2.4

package/dist/chunk-STLEUNK7.js

@@ -1,335 +0,0 @@
-import {
-  createCodegen,
-  ident,
-  slash
-} from "./chunk-2PY3JUIC.js";
-import {
-  fumaMatter
-} from "./chunk-VWJKRQZR.js";
-
-// src/plugins/index-file.ts
-import path2 from "path";
-import { glob } from "tinyglobby";
-
-// src/utils/fs-cache.ts
-import fs from "fs/promises";
-import path from "path";
-var map = /* @__PURE__ */ new Map();
-function createFSCache() {
-  return {
-    read(file) {
-      const fullPath = toFullPath(file);
-      const cached = map.get(fullPath);
-      if (cached) return cached;
-      const read = fs.readFile(fullPath).then((s) => s.toString());
-      map.set(fullPath, read);
-      return read;
-    },
-    delete(file) {
-      map.delete(toFullPath(file));
-    }
-  };
-}
-function toFullPath(file) {
-  if (path.isAbsolute(file)) {
-    return path.relative(process.cwd(), file);
-  }
-  return file;
-}
-
-// src/plugins/index-file.ts
-import { createHash } from "crypto";
-var indexFileCache = createFSCache();
-function indexFile(options = {}) {
-  const {
-    target = "default",
-    addJsExtension,
-    browser = true,
-    dynamic = true
-  } = options;
-  let dynamicCollections;
-  function isDynamic(collection) {
-    return collection.type === "docs" && collection.docs.dynamic || collection.type === "doc" && collection.dynamic;
-  }
-  function generateConfigs(core) {
-    const serverOptions = {};
-    const typeConfigs = [
-      'import("fumadocs-mdx/runtime/types").InternalTypeConfig'
-    ];
-    const ctx = core.getPluginContext();
-    for (const plugin of core.getPlugins()) {
-      const indexFilePlugin = plugin["index-file"];
-      if (!indexFilePlugin) continue;
-      indexFilePlugin.serverOptions?.call(ctx, serverOptions);
-      const config = indexFilePlugin.generateTypeConfig?.call(ctx);
-      if (config) typeConfigs.push(config);
-    }
-    return {
-      serverOptions,
-      tc: typeConfigs.join(" & ")
-    };
-  }
-  return {
-    name: "index-file",
-    config() {
-      dynamicCollections = this.core.getCollections().filter(isDynamic);
-    },
-    configureServer(server) {
-      if (!server.watcher) return;
-      server.watcher.on("all", async (event, file) => {
-        indexFileCache.delete(file);
-        if (dynamicCollections.length === 0) {
-          if (target === "vite") return;
-          if (target === "default" && event === "change") return;
-        }
-        const updatedCollection = this.core.getCollections().find((collection) => collection.hasFile(file));
-        if (!updatedCollection) return;
-        if (!isDynamic(updatedCollection)) {
-          if (target === "vite") return;
-          if (target === "default" && event === "change") return;
-        }
-        await this.core.emit({
-          filterPlugin: (plugin) => plugin.name === "index-file",
-          filterWorkspace: () => false,
-          write: true
-        });
-      });
-    },
-    async emit() {
-      const globCache = /* @__PURE__ */ new Map();
-      const { workspace, outDir } = this.core.getOptions();
-      const { serverOptions, tc } = generateConfigs(this.core);
-      const toEmitEntry = async (path3, content) => {
-        const codegen = createCodegen({
-          target,
-          outDir,
-          jsExtension: addJsExtension,
-          globCache
-        });
-        await content({
-          core: this.core,
-          codegen,
-          serverOptions,
-          tc,
-          workspace: workspace?.name
-        });
-        return {
-          path: path3,
-          content: codegen.toString()
-        };
-      };
-      const out = [
-        toEmitEntry("server.ts", generateServerIndexFile)
-      ];
-      if (dynamic)
-        out.push(toEmitEntry("dynamic.ts", generateDynamicIndexFile));
-      if (browser)
-        out.push(toEmitEntry("browser.ts", generateBrowserIndexFile));
-      return await Promise.all(out);
-    }
-  };
-}
-async function generateServerIndexFile(ctx) {
-  const { core, codegen, serverOptions, tc } = ctx;
-  codegen.lines.push(
-    `import { server } from 'fumadocs-mdx/runtime/server';`,
-    `import type * as Config from '${codegen.formatImportPath(core.getOptions().configPath)}';`,
-    "",
-    `const create = server<typeof Config, ${tc}>(${JSON.stringify(serverOptions)});`
-  );
-  async function generateCollectionObject(collection) {
-    const base = getBase(collection);
-    switch (collection.type) {
-      case "docs": {
-        if (collection.docs.dynamic) return;
-        if (collection.docs.async) {
-          const [metaGlob2, headGlob, bodyGlob] = await Promise.all([
-            generateMetaCollectionGlob(ctx, collection.meta, true),
-            generateDocCollectionFrontmatterGlob(ctx, collection.docs, true),
-            generateDocCollectionGlob(ctx, collection.docs)
-          ]);
-          return `await create.docsLazy("${collection.name}", "${base}", ${metaGlob2}, ${headGlob}, ${bodyGlob})`;
-        }
-        const [metaGlob, docGlob] = await Promise.all([
-          generateMetaCollectionGlob(ctx, collection.meta, true),
-          generateDocCollectionGlob(ctx, collection.docs, true)
-        ]);
-        return `await create.docs("${collection.name}", "${base}", ${metaGlob}, ${docGlob})`;
-      }
-      case "doc":
-        if (collection.dynamic) return;
-        if (collection.async) {
-          const [headGlob, bodyGlob] = await Promise.all([
-            generateDocCollectionFrontmatterGlob(ctx, collection, true),
-            generateDocCollectionGlob(ctx, collection)
-          ]);
-          return `await create.docLazy("${collection.name}", "${base}", ${headGlob}, ${bodyGlob})`;
-        }
-        return `await create.doc("${collection.name}", "${base}", ${await generateDocCollectionGlob(
-          ctx,
-          collection,
-          true
-        )})`;
-      case "meta":
-        return `await create.meta("${collection.name}", "${base}", ${await generateMetaCollectionGlob(
-          ctx,
-          collection,
-          true
-        )})`;
-    }
-  }
-  await codegen.pushAsync(
-    core.getCollections().map(async (collection) => {
-      const obj = await generateCollectionObject(collection);
-      if (!obj) return;
-      return `
-export const ${collection.name} = ${obj};`;
-    })
-  );
-}
-async function generateDynamicIndexFile(ctx) {
-  const { core, codegen, serverOptions, tc } = ctx;
-  const { configPath, environment, outDir } = core.getOptions();
-  const partialOptions = {
-    configPath,
-    environment,
-    outDir
-  };
-  codegen.lines.push(
-    `import { dynamic } from 'fumadocs-mdx/runtime/dynamic';`,
-    `import * as Config from '${codegen.formatImportPath(configPath)}';`,
-    "",
-    `const create = await dynamic<typeof Config, ${tc}>(Config, ${JSON.stringify(partialOptions)}, ${JSON.stringify(serverOptions)});`
-  );
-  async function generateCollectionObjectEntry(collection, absolutePath) {
-    const fullPath = path2.relative(process.cwd(), absolutePath);
-    const content = await indexFileCache.read(fullPath).catch(() => "");
-    const parsed = fumaMatter(content);
-    const data = await core.transformFrontmatter(
-      {
-        collection,
-        filePath: fullPath,
-        source: content
-      },
-      parsed.data
-    );
-    const hash = createHash("md5").update(content).digest("hex");
-    const infoStr = [
-      // make sure it's included in vercel/nft
-      `absolutePath: path.resolve(${JSON.stringify(fullPath)})`
-    ];
-    for (const [k, v] of Object.entries({
-      info: {
-        fullPath,
-        path: path2.relative(collection.dir, absolutePath)
-      },
-      data,
-      hash
-    })) {
-      infoStr.push(`${k}: ${JSON.stringify(v)}`);
-    }
-    return `{ ${infoStr.join(", ")} }`;
-  }
-  async function generateCollectionObject(parent) {
-    let collection;
-    if (parent.type === "doc") collection = parent;
-    else if (parent.type === "docs") collection = parent.docs;
-    if (!collection || !collection.dynamic) return;
-    const files = await glob(collection.patterns, {
-      cwd: collection.dir,
-      absolute: true
-    });
-    const entries = await Promise.all(
-      files.map((file) => generateCollectionObjectEntry(collection, file))
-    );
-    switch (parent.type) {
-      case "docs": {
-        const metaGlob = await generateMetaCollectionGlob(
-          ctx,
-          parent.meta,
-          true
-        );
-        return `await create.docs("${parent.name}", "${getBase(parent)}", ${metaGlob}, ${entries.join(", ")})`;
-      }
-      case "doc":
-        return `await create.doc("${collection.name}", "${getBase(collection)}", ${entries.join(", ")})`;
-    }
-  }
-  await codegen.pushAsync(
-    core.getCollections().map(async (collection) => {
-      const obj = await generateCollectionObject(collection);
-      if (!obj) return;
-      return `
-export const ${collection.name} = ${obj};`;
-    })
-  );
-}
-async function generateBrowserIndexFile(ctx) {
-  const { core, codegen, tc } = ctx;
-  codegen.lines.push(
-    `import { browser } from 'fumadocs-mdx/runtime/browser';`,
-    `import type * as Config from '${codegen.formatImportPath(core.getOptions().configPath)}';`,
-    "",
-    `const create = browser<typeof Config, ${tc}>();`
-  );
-  async function generateCollectionObject(collection) {
-    switch (collection.type) {
-      case "docs": {
-        if (collection.docs.dynamic) return;
-        return generateCollectionObject(collection.docs);
-      }
-      case "doc":
-        if (collection.dynamic) return;
-        return `create.doc("${collection.name}", ${await generateDocCollectionGlob(ctx, collection)})`;
-    }
-  }
-  codegen.lines.push("const browserCollections = {");
-  await codegen.pushAsync(
-    core.getCollections().map(async (collection) => {
-      const obj = await generateCollectionObject(collection);
-      if (!obj) return;
-      return ident(`${collection.name}: ${obj},`);
-    })
-  );
-  codegen.lines.push("};", "export default browserCollections;");
-}
-function getBase(collection) {
-  return slash(path2.relative(process.cwd(), collection.dir));
-}
-function generateDocCollectionFrontmatterGlob({ codegen, workspace }, collection, eager = false) {
-  return codegen.generateGlobImport(collection.patterns, {
-    query: {
-      collection: collection.name,
-      only: "frontmatter",
-      workspace
-    },
-    import: "frontmatter",
-    base: collection.dir,
-    eager
-  });
-}
-function generateDocCollectionGlob({ codegen, workspace }, collection, eager = false) {
-  return codegen.generateGlobImport(collection.patterns, {
-    query: {
-      collection: collection.name,
-      workspace
-    },
-    base: collection.dir,
-    eager
-  });
-}
-function generateMetaCollectionGlob({ codegen, workspace }, collection, eager = false) {
-  return codegen.generateGlobImport(collection.patterns, {
-    query: {
-      collection: collection.name,
-      workspace
-    },
-    import: "default",
-    base: collection.dir,
-    eager
-  });
-}
-
-export {
-  indexFile
-};

package/dist/chunk-USQZ5OLE.js

@@ -1,116 +0,0 @@
-import {
-  mdxLoaderGlob
-} from "./chunk-4JSFLXXT.js";
-import {
-  fumaMatter
-} from "./chunk-VWJKRQZR.js";
-
-// src/loaders/mdx/index.ts
-import { z } from "zod";
-import fs from "fs/promises";
-import path from "path";
-import { createHash } from "crypto";
-var querySchema = z.object({
-  only: z.literal(["frontmatter", "all"]).default("all"),
-  collection: z.string().optional(),
-  workspace: z.string().optional()
-}).loose();
-var cacheEntry = z.object({
-  code: z.string(),
-  map: z.any().optional(),
-  hash: z.string().optional()
-});
-function createMdxLoader({ getCore }) {
-  return {
-    test: mdxLoaderGlob,
-    async load({
-      getSource,
-      development: isDevelopment,
-      query,
-      compiler,
-      filePath
-    }) {
-      let core = await getCore();
-      const value = await getSource();
-      const matter = fumaMatter(value);
-      const {
-        collection: collectionName,
-        workspace,
-        only
-      } = querySchema.parse(query);
-      if (workspace) {
-        core = core.getWorkspaces().get(workspace) ?? core;
-      }
-      let after;
-      const { experimentalBuildCache = false } = core.getConfig().global;
-      if (!isDevelopment && experimentalBuildCache) {
-        const cacheDir = experimentalBuildCache;
-        const cacheKey = `${collectionName ?? "global"}_${generateCacheHash(filePath)}`;
-        const cached = await fs.readFile(path.join(cacheDir, cacheKey)).then((content) => cacheEntry.parse(JSON.parse(content.toString()))).catch(() => null);
-        if (cached && cached.hash === generateCacheHash(value)) return cached;
-        after = async () => {
-          await fs.mkdir(cacheDir, { recursive: true });
-          await fs.writeFile(
-            path.join(cacheDir, cacheKey),
-            JSON.stringify({
-              ...out,
-              hash: generateCacheHash(value)
-            })
-          );
-        };
-      }
-      const collection = collectionName ? core.getCollection(collectionName) : void 0;
-      let docCollection;
-      switch (collection?.type) {
-        case "doc":
-          docCollection = collection;
-          break;
-        case "docs":
-          docCollection = collection.docs;
-          break;
-      }
-      if (docCollection) {
-        matter.data = await core.transformFrontmatter(
-          { collection: docCollection, filePath, source: value },
-          matter.data
-        );
-      }
-      if (only === "frontmatter") {
-        return {
-          code: `export const frontmatter = ${JSON.stringify(matter.data)}`,
-          map: null
-        };
-      }
-      const lineOffset = isDevelopment ? countLines(matter.matter) : 0;
-      const { buildMDX } = await import("./build-mdx-5XLFMP5P.js");
-      const compiled = await buildMDX(core, docCollection, {
-        isDevelopment,
-        source: "\n".repeat(lineOffset) + matter.content,
-        filePath,
-        frontmatter: matter.data,
-        _compiler: compiler,
-        environment: "bundler"
-      });
-      const out = {
-        code: String(compiled.value),
-        map: compiled.map
-      };
-      await after?.();
-      return out;
-    }
-  };
-}
-function generateCacheHash(input) {
-  return createHash("md5").update(input).digest("hex");
-}
-function countLines(s) {
-  let num = 0;
-  for (const c of s) {
-    if (c === "\n") num++;
-  }
-  return num;
-}
-
-export {
-  createMdxLoader
-};

package/dist/chunk-VWJKRQZR.js

@@ -1,19 +0,0 @@
-// src/utils/fuma-matter.ts
-import { load } from "js-yaml";
-var regex = /^---\r?\n(.+?)\r?\n---\r?\n/s;
-function fumaMatter(input) {
-  const output = { matter: "", data: {}, content: input };
-  const match = regex.exec(input);
-  if (!match) {
-    return output;
-  }
-  output.matter = match[0];
-  output.content = input.slice(match[0].length);
-  const loaded = load(match[1]);
-  output.data = loaded ?? {};
-  return output;
-}
-
-export {
-  fumaMatter
-};